Code Examples

npm install tachles-pay effect

# For Upstash Redis storage
npm install @upstash/redis

# For Cloudflare Workers types
npm install -D @cloudflare/workers-types

import { Effect } from "effect";
import {
  createInfraLayer,
  runWithInfra,
  Database,
} from "tachles-pay";

// Create infrastructure with in-memory providers (great for dev/testing)
const layer = createInfraLayer();

// Define your payment flow using Effect
const createPayment = Effect.gen(function* () {
  const db = yield* Database;

  // 1. Create or get your app (represents a merchant/integration)
  const app = yield* db.createApp({
    name: "My E-Commerce Store",
    provider: "stripe",
    apiKey: process.env.STRIPE_SECRET_KEY!,
    webhookSecret: process.env.STRIPE_WEBHOOK_SECRET!,
    webhookUrl: "https://mystore.com/webhooks/stripe",
  });

  // 2. Create a payup (payment intent)
  const payup = yield* db.createPayup({
    appId: app.id,
    amount: 4999,           // $49.99 in cents
    currency: "USD",
    customerEmail: "customer@example.com",
    customerName: "John Doe",
    description: "Premium Plan - Monthly",
    returnUrl: "https://mystore.com/success",
    cancelUrl: "https://mystore.com/cancel",
    expiresAt: new Date(Date.now() + 30 * 60 * 1000), // 30 minutes
  });

  console.log("Payment created:", payup.id);
  console.log("Checkout URL:", `https://checkout.tachles.dev/${payup.id}`);

  return payup;
});

// Execute the effect with infrastructure
const payup = await runWithInfra(layer, createPayment);

// worker.ts - Cloudflare Workers deployment
import { Effect } from "effect";
import {
  makeFetchRuntime,
  Database,
  createCloudflareKVStorage,
  createMemoryStorage,
  type CloudflareEnv,
} from "tachles-pay/adapters/cloudflare";

// Request body types
interface CreatePayupBody {
  amount: number;
  currency?: string;
  customerEmail?: string;
  description?: string;
}

// Create request-scoped runtime
const runtime = makeFetchRuntime({
  // Use KV for persistence, fallback to memory for dev
  makeStorage: (env) =>
    env.TACHLES_KV 
      ? createCloudflareKVStorage(env.TACHLES_KV) 
      : createMemoryStorage(),
});

// Define your API handler
const handler = (request: Request, _env: CloudflareEnv) =>
  Effect.gen(function* () {
    const url = new URL(request.url);
    const db = yield* Database;

    // POST /api/payups - Create a new payment
    if (url.pathname === "/api/payups" && request.method === "POST") {
      const body = (yield* Effect.promise(() => request.json())) as CreatePayupBody;
      
      const payup = yield* db.createPayup({
        appId: "default-app",
        amount: body.amount,
        currency: body.currency || "USD",
        customerEmail: body.customerEmail,
        description: body.description,
        expiresAt: new Date(Date.now() + 60 * 60 * 1000),
      });

      return Response.json(payup, { status: 201 });
    }

    // GET /api/payups/:id - Get payment status
    if (url.pathname.startsWith("/api/payups/") && request.method === "GET") {
      const id = url.pathname.split("/").pop()!;
      const payup = yield* db.getPayup(id);
      
      if (!payup) {
        return Response.json({ error: "Not found" }, { status: 404 });
      }
      
      return Response.json(payup);
    }

    return Response.json({ error: "Not found" }, { status: 404 });
  });

// Export the worker
export default { fetch: runtime(handler) };

name = "tachles-api"
main = "src/worker.ts"
compatibility_date = "2024-01-01"

[[kv_namespaces]]
binding = "TACHLES_KV"
id = "your-kv-namespace-id"

// server.ts - Node.js HTTP server
import { Effect } from "effect";
import { startServer, Database } from "tachles-pay/adapters/node";

interface CreatePayupBody {
  amount: number;
  currency?: string;
  customerEmail?: string;
  description?: string;
}

const handler = (request: Request) =>
  Effect.gen(function* () {
    const url = new URL(request.url);
    const db = yield* Database;

    // Health check
    if (url.pathname === "/health") {
      return Response.json({ status: "ok", timestamp: new Date().toISOString() });
    }

    // Create payment
    if (url.pathname === "/api/payups" && request.method === "POST") {
      const body = (yield* Effect.promise(() => request.json())) as CreatePayupBody;
      
      const payup = yield* db.createPayup({
        appId: "default-app",
        amount: body.amount,
        currency: body.currency || "USD",
        customerEmail: body.customerEmail,
        description: body.description,
        expiresAt: new Date(Date.now() + 60 * 60 * 1000),
      });

      return Response.json(payup, { status: 201 });
    }

    // List payments
    if (url.pathname === "/api/payups" && request.method === "GET") {
      const payups = yield* db.listPayups();
      return Response.json(payups);
    }

    return Response.json({ error: "Not found" }, { status: 404 });
  }).pipe(
    Effect.catchAll((error) =>
      Effect.succeed(Response.json({ error: String(error) }, { status: 500 }))
    )
  );

// Start the server
const PORT = parseInt(process.env.PORT || "3000");

startServer({ port: PORT, handler }).then(({ url }) => {
  console.log(`🚀 Server running at ${url}`);
});

// api/webhooks/stripe/route.ts (Next.js App Router)
import { Effect } from "effect";
import { createInfraLayer, runWithInfra, Database } from "tachles-pay";
import { verifyWebhookSignature } from "tachles-pay";

const layer = createInfraLayer();

export async function POST(request: Request) {
  const body = await request.text();
  const signature = request.headers.get("stripe-signature");

  if (!signature) {
    return Response.json({ error: "Missing signature" }, { status: 400 });
  }

  const program = Effect.gen(function* () {
    const db = yield* Database;

    // Get the app to retrieve webhook secret
    const apps = yield* db.listApps();
    const app = apps.find((a) => a.provider === "stripe");

    if (!app) {
      return Response.json({ error: "App not found" }, { status: 404 });
    }

    // Verify webhook signature
    const isValid = yield* verifyWebhookSignature({
      payload: body,
      signature,
      secret: app.webhookSecret,
    });

    if (!isValid) {
      return Response.json({ error: "Invalid signature" }, { status: 401 });
    }

    // Parse and handle the event
    const event = JSON.parse(body);

    switch (event.type) {
      case "payment_intent.succeeded": {
        const paymentIntent = event.data.object;
        
        // Find and update the payup
        const payups = yield* db.listPayups({ appId: app.id });
        const payup = payups.find((p) => 
          p.providerPaymentId === paymentIntent.id
        );

        if (payup) {
          yield* db.updatePayup(payup.id, {
            status: "completed",
            providerData: paymentIntent,
          });
        }
        break;
      }

      case "payment_intent.payment_failed": {
        const paymentIntent = event.data.object;
        
        const payups = yield* db.listPayups({ appId: app.id });
        const payup = payups.find((p) => 
          p.providerPaymentId === paymentIntent.id
        );

        if (payup) {
          yield* db.updatePayup(payup.id, {
            status: "failed",
            providerData: paymentIntent,
          });
        }
        break;
      }
    }

    return Response.json({ received: true });
  });

  return runWithInfra(layer, program);
}