Loops

# npm
npm install loops

# yarn
yarn add loops

# pnpm
pnpm add loops

// lib/loops.ts
import { LoopsClient } from 'loops'

// Singleton pattern dla client
let loopsClient: LoopsClient | null = null

export function getLoopsClient(): LoopsClient {
  if (!loopsClient) {
    const apiKey = process.env.LOOPS_API_KEY

    if (!apiKey) {
      throw new Error('LOOPS_API_KEY is required')
    }

    loopsClient = new LoopsClient(apiKey)
  }

  return loopsClient
}

// Eksport dla wygody
export const loops = getLoopsClient()

// app/api/loops/route.ts
import { NextRequest, NextResponse } from 'next/server'
import { LoopsClient } from 'loops'

const loops = new LoopsClient(process.env.LOOPS_API_KEY!)

export async function POST(request: NextRequest) {
  try {
    const { action, ...data } = await request.json()

    switch (action) {
      case 'createContact':
        const contact = await loops.createContact(data)
        return NextResponse.json({ success: true, contact })

      case 'sendEvent':
        await loops.sendEvent(data)
        return NextResponse.json({ success: true })

      case 'sendTransactional':
        await loops.sendTransactionalEmail(data)
        return NextResponse.json({ success: true })

      default:
        return NextResponse.json(
          { error: 'Unknown action' },
          { status: 400 }
        )
    }
  } catch (error) {
    console.error('Loops API error:', error)
    return NextResponse.json(
      { error: 'Failed to process request' },
      { status: 500 }
    )
  }
}

# .env.local
LOOPS_API_KEY=your_api_key_here

# Opcjonalnie - custom endpoint dla self-hosted
LOOPS_API_URL=https://app.loops.so/api/v1

import { LoopsClient } from 'loops'

const loops = new LoopsClient(process.env.LOOPS_API_KEY!)

// Podstawowe tworzenie kontaktu
async function createBasicContact(email: string, firstName: string) {
  const result = await loops.createContact({
    email,
    firstName,
    source: 'website',
  })

  return result
}

// Pełny kontakt z custom properties
async function createFullContact(userData: {
  email: string
  firstName: string
  lastName: string
  company?: string
  plan?: string
  signupDate?: Date
}) {
  const result = await loops.createContact({
    email: userData.email,
    firstName: userData.firstName,
    lastName: userData.lastName,
    source: 'app-signup',
    userGroup: 'free-trial',

    // Custom properties (muszą być wcześniej zdefiniowane w Loops)
    company: userData.company,
    plan: userData.plan || 'free',
    signupDate: userData.signupDate?.toISOString(),
  })

  return result
}

// Aktualizacja istniejącego kontaktu
async function updateContact(
  email: string,
  updates: Record<string, any>
) {
  const result = await loops.updateContact({
    email,
    ...updates,
  })

  return result
}

// Przykład: Aktualizacja planu po upgrade
async function handlePlanUpgrade(email: string, newPlan: string) {
  await loops.updateContact({
    email,
    plan: newPlan,
    upgradedAt: new Date().toISOString(),
    userGroup: 'paying-customer',
  })

  // Wyślij event dla automation
  await loops.sendEvent({
    email,
    eventName: 'plan_upgraded',
    eventProperties: {
      newPlan,
      upgradedAt: new Date().toISOString(),
    },
  })
}

// Znajdź kontakt po email
async function findContact(email: string) {
  const contact = await loops.findContact({ email })
  return contact
}

// Usuń kontakt
async function deleteContact(email: string) {
  await loops.deleteContact({ email })
}

// Batch operacje - tworzenie wielu kontaktów
async function importContacts(contacts: Array<{
  email: string
  firstName: string
  source: string
}>) {
  const results = await Promise.allSettled(
    contacts.map(contact => loops.createContact(contact))
  )

  const succeeded = results.filter(r => r.status === 'fulfilled').length
  const failed = results.filter(r => r.status === 'rejected').length

  console.log(`Imported: ${succeeded} succeeded, ${failed} failed`)

  return { succeeded, failed }
}

// Podstawowy transactional email
async function sendWelcomeEmail(
  email: string,
  firstName: string,
  loginUrl: string
) {
  await loops.sendTransactionalEmail({
    transactionalId: 'welcome-email', // ID z Loops dashboard
    email,
    dataVariables: {
      firstName,
      loginUrl,
    },
  })
}

// Email z wieloma zmiennymi
async function sendOrderConfirmation(order: {
  email: string
  orderNumber: string
  items: Array<{ name: string; quantity: number; price: number }>
  total: number
  shippingAddress: string
}) {
  await loops.sendTransactionalEmail({
    transactionalId: 'order-confirmation',
    email: order.email,
    dataVariables: {
      orderNumber: order.orderNumber,
      itemsHtml: order.items
        .map(item => `<li>${item.name} x${item.quantity} - $${item.price}</li>`)
        .join(''),
      total: order.total.toFixed(2),
      shippingAddress: order.shippingAddress,
    },
  })
}

// Reset hasła
async function sendPasswordReset(email: string, resetToken: string) {
  const resetUrl = `${process.env.NEXT_PUBLIC_APP_URL}/reset-password?token=${resetToken}`

  await loops.sendTransactionalEmail({
    transactionalId: 'password-reset',
    email,
    dataVariables: {
      resetUrl,
      expiresIn: '24 hours',
    },
  })
}

// Weryfikacja email
async function sendVerificationEmail(
  email: string,
  verificationToken: string
) {
  const verifyUrl = `${process.env.NEXT_PUBLIC_APP_URL}/verify-email?token=${verificationToken}`

  await loops.sendTransactionalEmail({
    transactionalId: 'email-verification',
    email,
    dataVariables: {
      verifyUrl,
    },
  })
}

// Powiadomienie o nowym urządzeniu/logowaniu
async function sendNewLoginAlert(
  email: string,
  loginDetails: {
    device: string
    location: string
    time: Date
    ip: string
  }
) {
  await loops.sendTransactionalEmail({
    transactionalId: 'new-login-alert',
    email,
    dataVariables: {
      device: loginDetails.device,
      location: loginDetails.location,
      time: loginDetails.time.toLocaleString(),
      ip: loginDetails.ip,
    },
  })
}

// Email z załącznikiem (base64 encoded)
async function sendInvoiceEmail(
  email: string,
  invoiceNumber: string,
  pdfContent: Buffer
) {
  await loops.sendTransactionalEmail({
    transactionalId: 'invoice',
    email,
    dataVariables: {
      invoiceNumber,
    },
    attachments: [
      {
        filename: `invoice-${invoiceNumber}.pdf`,
        contentType: 'application/pdf',
        data: pdfContent.toString('base64'),
      },
    ],
  })
}

// Podstawowy event
async function trackEvent(email: string, eventName: string) {
  await loops.sendEvent({
    email,
    eventName,
  })
}

// Event z properties
async function trackSignup(email: string, signupData: {
  plan: string
  referralSource: string
  utmSource?: string
  utmCampaign?: string
}) {
  await loops.sendEvent({
    email,
    eventName: 'user_signed_up',
    eventProperties: {
      plan: signupData.plan,
      referralSource: signupData.referralSource,
      utmSource: signupData.utmSource || 'direct',
      utmCampaign: signupData.utmCampaign || 'none',
      signedUpAt: new Date().toISOString(),
    },
  })
}

// Event subskrypcji
async function trackSubscription(email: string, subscription: {
  plan: string
  interval: 'monthly' | 'yearly'
  amount: number
  currency: string
}) {
  await loops.sendEvent({
    email,
    eventName: 'subscription_started',
    eventProperties: {
      plan: subscription.plan,
      interval: subscription.interval,
      amount: subscription.amount,
      currency: subscription.currency,
      mrr: subscription.interval === 'yearly'
        ? subscription.amount / 12
        : subscription.amount,
    },
  })
}

// Kompletny tracking lifecycle użytkownika
class UserLifecycleTracker {
  constructor(private loops: LoopsClient) {}

  async onSignup(user: { email: string; firstName: string; plan: string }) {
    // Utwórz kontakt
    await this.loops.createContact({
      email: user.email,
      firstName: user.firstName,
      source: 'app',
      userGroup: 'trial',
      plan: user.plan,
    })

    // Wyślij event
    await this.loops.sendEvent({
      email: user.email,
      eventName: 'signed_up',
      eventProperties: { plan: user.plan },
    })
  }

  async onFirstLogin(email: string) {
    await this.loops.sendEvent({
      email,
      eventName: 'first_login',
    })
  }

  async onFeatureUsed(email: string, feature: string) {
    await this.loops.sendEvent({
      email,
      eventName: 'feature_used',
      eventProperties: { feature },
    })
  }

  async onTrialExpiring(email: string, daysLeft: number) {
    await this.loops.sendEvent({
      email,
      eventName: 'trial_expiring',
      eventProperties: { daysLeft },
    })
  }

  async onTrialExpired(email: string) {
    await this.loops.updateContact({
      email,
      userGroup: 'expired-trial',
    })

    await this.loops.sendEvent({
      email,
      eventName: 'trial_expired',
    })
  }

  async onUpgrade(email: string, plan: string, amount: number) {
    await this.loops.updateContact({
      email,
      userGroup: 'paying',
      plan,
    })

    await this.loops.sendEvent({
      email,
      eventName: 'upgraded',
      eventProperties: { plan, amount },
    })
  }

  async onChurn(email: string, reason?: string) {
    await this.loops.updateContact({
      email,
      userGroup: 'churned',
    })

    await this.loops.sendEvent({
      email,
      eventName: 'churned',
      eventProperties: { reason: reason || 'unknown' },
    })
  }
}

// app/actions/loops.ts
'use server'

import { LoopsClient } from 'loops'

const loops = new LoopsClient(process.env.LOOPS_API_KEY!)

export async function trackUserAction(
  email: string,
  action: string,
  metadata?: Record<string, any>
) {
  try {
    await loops.sendEvent({
      email,
      eventName: action,
      eventProperties: metadata,
    })
    return { success: true }
  } catch (error) {
    console.error('Failed to track action:', error)
    return { success: false, error: 'Failed to track action' }
  }
}

export async function subscribeToNewsletter(formData: FormData) {
  const email = formData.get('email') as string
  const firstName = formData.get('firstName') as string

  try {
    await loops.createContact({
      email,
      firstName,
      source: 'newsletter',
      userGroup: 'newsletter-subscribers',
    })

    return { success: true }
  } catch (error) {
    console.error('Newsletter signup failed:', error)
    return { success: false, error: 'Signup failed' }
  }
}

// Dodaj do listy
async function addToMailingList(
  email: string,
  listId: string
) {
  await loops.mailingLists.add({
    email,
    mailingListId: listId,
  })
}

// Usuń z listy
async function removeFromMailingList(
  email: string,
  listId: string
) {
  await loops.mailingLists.remove({
    email,
    mailingListId: listId,
  })
}

// Zarządzanie preferencjami newslettera
async function updateNewsletterPreferences(
  email: string,
  preferences: {
    productUpdates: boolean
    weeklyDigest: boolean
    promotions: boolean
    tips: boolean
  }
) {
  const addPromises: Promise<void>[] = []
  const removePromises: Promise<void>[] = []

  const lists = {
    productUpdates: 'list_product_updates',
    weeklyDigest: 'list_weekly_digest',
    promotions: 'list_promotions',
    tips: 'list_tips',
  }

  for (const [key, listId] of Object.entries(lists)) {
    const isSubscribed = preferences[key as keyof typeof preferences]

    if (isSubscribed) {
      addPromises.push(
        loops.mailingLists.add({ email, mailingListId: listId })
      )
    } else {
      removePromises.push(
        loops.mailingLists.remove({ email, mailingListId: listId })
      )
    }
  }

  await Promise.all([...addPromises, ...removePromises])
}

// Segmentacja na podstawie zachowania
async function segmentUserByBehavior(email: string, behavior: {
  lastLoginDays: number
  featuresUsed: number
  planType: string
}) {
  let userGroup: string

  if (behavior.lastLoginDays > 30) {
    userGroup = 'at-risk'
  } else if (behavior.featuresUsed > 10 && behavior.planType === 'free') {
    userGroup = 'upgrade-candidate'
  } else if (behavior.planType !== 'free') {
    userGroup = 'paying-active'
  } else {
    userGroup = 'free-active'
  }

  await loops.updateContact({
    email,
    userGroup,
    lastLoginDays: behavior.lastLoginDays,
    featuresUsed: behavior.featuresUsed,
  })

  // Dodaj do odpowiedniej listy mailingowej
  const listMapping: Record<string, string> = {
    'at-risk': 'list_reengagement',
    'upgrade-candidate': 'list_upgrade_offers',
    'paying-active': 'list_premium_content',
    'free-active': 'list_conversion',
  }

  const listId = listMapping[userGroup]
  if (listId) {
    await loops.mailingLists.add({ email, mailingListId: listId })
  }
}

// app/api/webhooks/loops/route.ts
import { NextRequest, NextResponse } from 'next/server'
import crypto from 'crypto'

// Typy dla webhook events
interface LoopsWebhookEvent {
  type:
    | 'email.sent'
    | 'email.delivered'
    | 'email.opened'
    | 'email.clicked'
    | 'email.bounced'
    | 'email.complained'
    | 'contact.subscribed'
    | 'contact.unsubscribed'
  data: {
    email: string
    timestamp: string
    transactionalId?: string
    campaignId?: string
    link?: string
    bounceType?: 'hard' | 'soft'
  }
}

// Weryfikacja podpisu webhook
function verifyWebhookSignature(
  payload: string,
  signature: string,
  secret: string
): boolean {
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(payload)
    .digest('hex')

  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expectedSignature)
  )
}

export async function POST(request: NextRequest) {
  const payload = await request.text()
  const signature = request.headers.get('x-loops-signature') || ''

  // Weryfikuj podpis
  if (!verifyWebhookSignature(
    payload,
    signature,
    process.env.LOOPS_WEBHOOK_SECRET!
  )) {
    return NextResponse.json(
      { error: 'Invalid signature' },
      { status: 401 }
    )
  }

  const event: LoopsWebhookEvent = JSON.parse(payload)

  try {
    switch (event.type) {
      case 'email.delivered':
        await handleEmailDelivered(event.data)
        break

      case 'email.opened':
        await handleEmailOpened(event.data)
        break

      case 'email.clicked':
        await handleEmailClicked(event.data)
        break

      case 'email.bounced':
        await handleEmailBounced(event.data)
        break

      case 'email.complained':
        await handleSpamComplaint(event.data)
        break

      case 'contact.unsubscribed':
        await handleUnsubscribe(event.data)
        break
    }

    return NextResponse.json({ received: true })
  } catch (error) {
    console.error('Webhook processing error:', error)
    return NextResponse.json(
      { error: 'Processing failed' },
      { status: 500 }
    )
  }
}

// Handlery dla różnych eventów
async function handleEmailDelivered(data: LoopsWebhookEvent['data']) {
  // Zapisz w analytics
  await prisma.emailEvent.create({
    data: {
      email: data.email,
      type: 'delivered',
      timestamp: new Date(data.timestamp),
      campaignId: data.campaignId,
    },
  })
}

async function handleEmailOpened(data: LoopsWebhookEvent['data']) {
  await prisma.emailEvent.create({
    data: {
      email: data.email,
      type: 'opened',
      timestamp: new Date(data.timestamp),
      campaignId: data.campaignId,
    },
  })

  // Aktualizuj engagement score użytkownika
  await prisma.user.update({
    where: { email: data.email },
    data: {
      lastEmailOpened: new Date(),
      emailEngagementScore: { increment: 1 },
    },
  })
}

async function handleEmailClicked(data: LoopsWebhookEvent['data']) {
  await prisma.emailEvent.create({
    data: {
      email: data.email,
      type: 'clicked',
      timestamp: new Date(data.timestamp),
      campaignId: data.campaignId,
      link: data.link,
    },
  })

  // Wyższy engagement za kliknięcie
  await prisma.user.update({
    where: { email: data.email },
    data: {
      emailEngagementScore: { increment: 5 },
    },
  })
}

async function handleEmailBounced(data: LoopsWebhookEvent['data']) {
  if (data.bounceType === 'hard') {
    // Hard bounce - oznacz email jako nieprawidłowy
    await prisma.user.update({
      where: { email: data.email },
      data: {
        emailStatus: 'invalid',
        emailInvalidAt: new Date(),
      },
    })
  } else {
    // Soft bounce - śledź, ale nie blokuj
    await prisma.emailBounce.create({
      data: {
        email: data.email,
        type: 'soft',
        timestamp: new Date(data.timestamp),
      },
    })
  }
}

async function handleSpamComplaint(data: LoopsWebhookEvent['data']) {
  // Natychmiastowy unsubscribe przy complaint
  await prisma.user.update({
    where: { email: data.email },
    data: {
      emailStatus: 'complained',
      unsubscribedAt: new Date(),
      unsubscribeReason: 'spam_complaint',
    },
  })
}

async function handleUnsubscribe(data: LoopsWebhookEvent['data']) {
  await prisma.user.update({
    where: { email: data.email },
    data: {
      emailStatus: 'unsubscribed',
      unsubscribedAt: new Date(),
    },
  })
}

// auth.ts
import NextAuth from 'next-auth'
import { LoopsClient } from 'loops'

const loops = new LoopsClient(process.env.LOOPS_API_KEY!)

export const { handlers, auth, signIn, signOut } = NextAuth({
  // ...other config
  events: {
    async signIn({ user, isNewUser }) {
      if (isNewUser && user.email) {
        // Nowy użytkownik - dodaj do Loops
        await loops.createContact({
          email: user.email,
          firstName: user.name?.split(' ')[0] || '',
          source: 'app-signup',
          userGroup: 'new-users',
        })

        await loops.sendEvent({
          email: user.email,
          eventName: 'signed_up',
        })
      } else if (user.email) {
        // Istniejący użytkownik - track login
        await loops.sendEvent({
          email: user.email,
          eventName: 'logged_in',
        })
      }
    },
  },
})

// app/api/webhooks/clerk/route.ts
import { Webhook } from 'svix'
import { headers } from 'next/headers'
import { WebhookEvent } from '@clerk/nextjs/server'
import { LoopsClient } from 'loops'

const loops = new LoopsClient(process.env.LOOPS_API_KEY!)

export async function POST(req: Request) {
  const WEBHOOK_SECRET = process.env.CLERK_WEBHOOK_SECRET

  if (!WEBHOOK_SECRET) {
    throw new Error('Missing CLERK_WEBHOOK_SECRET')
  }

  const headerPayload = headers()
  const svix_id = headerPayload.get('svix-id')
  const svix_timestamp = headerPayload.get('svix-timestamp')
  const svix_signature = headerPayload.get('svix-signature')

  const body = await req.text()

  const wh = new Webhook(WEBHOOK_SECRET)
  let evt: WebhookEvent

  try {
    evt = wh.verify(body, {
      'svix-id': svix_id!,
      'svix-timestamp': svix_timestamp!,
      'svix-signature': svix_signature!,
    }) as WebhookEvent
  } catch (err) {
    return new Response('Invalid signature', { status: 400 })
  }

  switch (evt.type) {
    case 'user.created':
      await loops.createContact({
        email: evt.data.email_addresses[0]?.email_address!,
        firstName: evt.data.first_name || '',
        lastName: evt.data.last_name || '',
        source: 'clerk-signup',
        userId: evt.data.id,
      })
      break

    case 'user.updated':
      await loops.updateContact({
        email: evt.data.email_addresses[0]?.email_address!,
        firstName: evt.data.first_name || '',
        lastName: evt.data.last_name || '',
      })
      break

    case 'user.deleted':
      if (evt.data.email_addresses?.[0]) {
        await loops.deleteContact({
          email: evt.data.email_addresses[0].email_address,
        })
      }
      break
  }

  return new Response('OK', { status: 200 })
}

// app/api/webhooks/stripe/route.ts
import { NextRequest, NextResponse } from 'next/server'
import Stripe from 'stripe'
import { LoopsClient } from 'loops'

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!)
const loops = new LoopsClient(process.env.LOOPS_API_KEY!)

export async function POST(request: NextRequest) {
  const body = await request.text()
  const signature = request.headers.get('stripe-signature')!

  let event: Stripe.Event

  try {
    event = stripe.webhooks.constructEvent(
      body,
      signature,
      process.env.STRIPE_WEBHOOK_SECRET!
    )
  } catch (err) {
    return NextResponse.json(
      { error: 'Invalid signature' },
      { status: 400 }
    )
  }

  switch (event.type) {
    case 'customer.subscription.created': {
      const subscription = event.data.object as Stripe.Subscription
      const customer = await stripe.customers.retrieve(
        subscription.customer as string
      ) as Stripe.Customer

      if (customer.email) {
        await loops.updateContact({
          email: customer.email,
          userGroup: 'paying',
          plan: subscription.items.data[0]?.price.nickname || 'unknown',
          subscriptionStatus: subscription.status,
        })

        await loops.sendEvent({
          email: customer.email,
          eventName: 'subscription_created',
          eventProperties: {
            plan: subscription.items.data[0]?.price.nickname,
            amount: subscription.items.data[0]?.price.unit_amount! / 100,
            interval: subscription.items.data[0]?.price.recurring?.interval,
          },
        })
      }
      break
    }

    case 'customer.subscription.updated': {
      const subscription = event.data.object as Stripe.Subscription
      const customer = await stripe.customers.retrieve(
        subscription.customer as string
      ) as Stripe.Customer

      if (customer.email) {
        await loops.updateContact({
          email: customer.email,
          plan: subscription.items.data[0]?.price.nickname || 'unknown',
          subscriptionStatus: subscription.status,
        })

        // Sprawdź czy to upgrade
        const previousPlan = event.data.previous_attributes?.items?.data[0]
          ?.price?.unit_amount
        const currentPlan = subscription.items.data[0]?.price.unit_amount

        if (previousPlan && currentPlan && currentPlan > previousPlan) {
          await loops.sendEvent({
            email: customer.email,
            eventName: 'subscription_upgraded',
            eventProperties: {
              newPlan: subscription.items.data[0]?.price.nickname,
              newAmount: currentPlan / 100,
            },
          })
        }
      }
      break
    }

    case 'customer.subscription.deleted': {
      const subscription = event.data.object as Stripe.Subscription
      const customer = await stripe.customers.retrieve(
        subscription.customer as string
      ) as Stripe.Customer

      if (customer.email) {
        await loops.updateContact({
          email: customer.email,
          userGroup: 'churned',
          subscriptionStatus: 'canceled',
          churnedAt: new Date().toISOString(),
        })

        await loops.sendEvent({
          email: customer.email,
          eventName: 'subscription_canceled',
        })
      }
      break
    }

    case 'invoice.payment_failed': {
      const invoice = event.data.object as Stripe.Invoice

      if (invoice.customer_email) {
        await loops.sendEvent({
          email: invoice.customer_email,
          eventName: 'payment_failed',
          eventProperties: {
            amount: invoice.amount_due / 100,
            attemptCount: invoice.attempt_count,
          },
        })
      }
      break
    }
  }

  return NextResponse.json({ received: true })
}

import { LoopsClient } from 'loops'

const loops = new LoopsClient(process.env.LOOPS_API_KEY!)

// Wrapper z retry logic
async function withRetry<T>(
  operation: () => Promise<T>,
  maxRetries = 3,
  delay = 1000
): Promise<T> {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await operation()
    } catch (error) {
      if (attempt === maxRetries) {
        throw error
      }

      console.warn(`Attempt ${attempt} failed, retrying in ${delay}ms...`)
      await new Promise(resolve => setTimeout(resolve, delay))
      delay *= 2 // Exponential backoff
    }
  }

  throw new Error('Max retries exceeded')
}

// Bezpieczne wysyłanie emaili
async function safeSendTransactional(
  transactionalId: string,
  email: string,
  dataVariables: Record<string, any>
) {
  try {
    await withRetry(() =>
      loops.sendTransactionalEmail({
        transactionalId,
        email,
        dataVariables,
      })
    )
    return { success: true }
  } catch (error) {
    console.error('Failed to send email:', error)

    // Zapisz do kolejki do ponowienia później
    await queueFailedEmail({
      type: 'transactional',
      transactionalId,
      email,
      dataVariables,
      error: error instanceof Error ? error.message : 'Unknown error',
    })

    return { success: false, error }
  }
}