paddle-checkout-accelerator 2.1.0

package/dist/src/components/paddle/gates/SubscriptionGate.js

@@ -0,0 +1,8 @@
+"use client";
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+export function SubscriptionGate({ active, children, fallback, }) {
+    if (!active) {
+        return (fallback ?? (_jsx("div", { className: "rounded-xl border p-6", children: "Upgrade required." })));
+    }
+    return _jsx(_Fragment, { children: children });
+}

package/dist/src/lib/billing/adapters/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./memory";
+export * from "./prisma";

package/dist/src/lib/billing/adapters/index.js

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./memory";
+export * from "./prisma";

package/dist/src/lib/billing/adapters/memory.d.ts

@@ -0,0 +1,2 @@
+import type { BillingAdapter } from "./types";
+export declare const memoryBillingAdapter: BillingAdapter;

package/dist/src/lib/billing/adapters/memory.js

@@ -0,0 +1,41 @@
+const subscriptions = new Map();
+const usage = new Map();
+const teams = new Map();
+const billingEvents = new Map();
+function usageKey(userId, key, period) {
+    return `${userId}:${key}:${period}`;
+}
+export const memoryBillingAdapter = {
+    async getSubscription(userId) {
+        return subscriptions.get(userId) ?? null;
+    },
+    async upsertSubscription(record) {
+        subscriptions.set(record.userId, record);
+        return record;
+    },
+    async getUsage(userId, key, period) {
+        return (usage.get(usageKey(userId, key, period)) ?? 0);
+    },
+    async incrementUsage(userId, key, period, amount) {
+        const id = usageKey(userId, key, period);
+        const next = (usage.get(id) ?? 0) + amount;
+        usage.set(id, next);
+        return next;
+    },
+    async getTeam(teamId) {
+        return teams.get(teamId) ?? null;
+    },
+    async upsertTeam(team) {
+        teams.set(team.teamId, team);
+        return team;
+    },
+    async recordBillingEvent(event) {
+        const current = billingEvents.get(event.userId) ?? [];
+        current.unshift(event);
+        billingEvents.set(event.userId, current);
+        return event;
+    },
+    async getBillingEvents(userId) {
+        return (billingEvents.get(userId) ?? []);
+    },
+};

package/dist/src/lib/billing/adapters/prisma/index.d.ts

@@ -0,0 +1,28 @@
+import type { BillingAdapter } from "../types";
+import type { SubscriptionRecord } from "../../subscriptions";
+import type { TeamRecord } from "../../teams";
+import type { BillingEvent } from "../../events";
+type PrismaLike = {
+    subscription: {
+        findUnique(args: unknown): Promise<SubscriptionRecord | null>;
+        upsert(args: unknown): Promise<SubscriptionRecord>;
+    };
+    usageEvent: {
+        findUnique(args: unknown): Promise<{
+            count: number;
+        } | null>;
+        upsert(args: unknown): Promise<{
+            count: number;
+        }>;
+    };
+    team: {
+        findUnique(args: unknown): Promise<TeamRecord | null>;
+        upsert(args: unknown): Promise<TeamRecord>;
+    };
+    billingEvent: {
+        create(args: unknown): Promise<BillingEvent>;
+        findMany(args: unknown): Promise<BillingEvent[]>;
+    };
+};
+export declare function createPrismaBillingAdapter(prisma: PrismaLike): BillingAdapter;
+export {};

package/dist/src/lib/billing/adapters/prisma/index.js

@@ -0,0 +1,80 @@
+export function createPrismaBillingAdapter(prisma) {
+    return {
+        async getSubscription(userId) {
+            return prisma.subscription.findUnique({
+                where: { userId },
+            });
+        },
+        async upsertSubscription(record) {
+            return prisma.subscription.upsert({
+                where: {
+                    userId: record.userId,
+                },
+                create: record,
+                update: record,
+            });
+        },
+        async getUsage(userId, key, period) {
+            const usage = await prisma.usageEvent.findUnique({
+                where: {
+                    userId_key_period: {
+                        userId,
+                        key,
+                        period,
+                    },
+                },
+            });
+            return usage?.count ?? 0;
+        },
+        async incrementUsage(userId, key, period, amount) {
+            const usage = await prisma.usageEvent.upsert({
+                where: {
+                    userId_key_period: {
+                        userId,
+                        key,
+                        period,
+                    },
+                },
+                create: {
+                    userId,
+                    key,
+                    period,
+                    count: amount,
+                },
+                update: {
+                    count: {
+                        increment: amount,
+                    },
+                },
+            });
+            return usage.count;
+        },
+        async getTeam(teamId) {
+            return prisma.team.findUnique({
+                where: { teamId },
+            });
+        },
+        async upsertTeam(team) {
+            return prisma.team.upsert({
+                where: {
+                    teamId: team.teamId,
+                },
+                create: team,
+                update: team,
+            });
+        },
+        async recordBillingEvent(event) {
+            return prisma.billingEvent.create({
+                data: event,
+            });
+        },
+        async getBillingEvents(userId) {
+            return prisma.billingEvent.findMany({
+                where: { userId },
+                orderBy: {
+                    createdAt: "desc",
+                },
+            });
+        },
+    };
+}

package/dist/src/lib/billing/adapters/types.d.ts

@@ -0,0 +1,13 @@
+import type { SubscriptionRecord } from "../subscriptions";
+import type { TeamRecord } from "../teams";
+import type { BillingEvent } from "../events";
+export interface BillingAdapter {
+    getSubscription(userId: string): Promise<SubscriptionRecord | null>;
+    upsertSubscription(record: SubscriptionRecord): Promise<SubscriptionRecord>;
+    getUsage(userId: string, key: string, period: string): Promise<number>;
+    incrementUsage(userId: string, key: string, period: string, amount: number): Promise<number>;
+    getTeam?(teamId: string): Promise<TeamRecord | null>;
+    upsertTeam?(team: TeamRecord): Promise<TeamRecord>;
+    recordBillingEvent?(event: BillingEvent): Promise<BillingEvent>;
+    getBillingEvents?(userId: string): Promise<BillingEvent[]>;
+}

package/dist/src/lib/billing/adapters/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/lib/billing/configure.d.ts

@@ -0,0 +1,6 @@
+import type { BillingAdapter } from "./adapters";
+export declare function configureBilling({ adapter, }: {
+    adapter: BillingAdapter;
+}): {
+    adapterConfigured: boolean;
+};

package/dist/src/lib/billing/configure.js

@@ -0,0 +1,13 @@
+import { setBillingAdapter } from "./subscriptions";
+import { setUsageAdapter } from "./usage";
+import { setTeamAdapter } from "./teams";
+import { setBillingEventAdapter } from "./events";
+export function configureBilling({ adapter, }) {
+    setBillingAdapter(adapter);
+    setUsageAdapter(adapter);
+    setTeamAdapter(adapter);
+    setBillingEventAdapter(adapter);
+    return {
+        adapterConfigured: true,
+    };
+}

package/dist/src/lib/billing/customer-repair.d.ts

@@ -0,0 +1,4 @@
+export declare function repairSubscriptionByEmail(email: string): Promise<{
+    customer: import("@/lib/paddle/customers").PaddleCustomer;
+    subscription: import("./subscriptions").SubscriptionRecord;
+}>;

package/dist/src/lib/billing/customer-repair.js

@@ -0,0 +1,19 @@
+import { findFirstPaddleCustomerByEmail } from "@/lib/paddle/customers";
+import { fetchPaddleSubscriptionsForCustomer } from "@/lib/paddle/subscriptions";
+import { refreshSubscriptionFromPaddle } from "./refresh";
+export async function repairSubscriptionByEmail(email) {
+    const customer = await findFirstPaddleCustomerByEmail(email);
+    if (!customer) {
+        throw new Error("No Paddle customer found for email");
+    }
+    const subscriptions = await fetchPaddleSubscriptionsForCustomer(customer.id);
+    const activeSubscription = subscriptions.data?.find((sub) => ["active", "trialing", "past_due"].includes(sub.status));
+    if (!activeSubscription) {
+        throw new Error("No active Paddle subscription found for customer");
+    }
+    const repaired = await refreshSubscriptionFromPaddle(activeSubscription.id);
+    return {
+        customer,
+        subscription: repaired,
+    };
+}

package/dist/src/lib/billing/demo-seed.d.ts

@@ -0,0 +1 @@
+export declare function seedDemoBilling(): Promise<void>;

package/dist/src/lib/billing/demo-seed.js

@@ -0,0 +1,13 @@
+import { upsertSubscription } from "./subscriptions";
+let seeded = false;
+export async function seedDemoBilling() {
+    if (seeded) {
+        return;
+    }
+    await upsertSubscription({
+        userId: "demo-user-1",
+        plan: "pro",
+        status: "active",
+    });
+    seeded = true;
+}

package/dist/src/lib/billing/entitlements.d.ts

@@ -0,0 +1,3 @@
+import { type FeatureKey } from "./plans";
+export declare function hasFeature(userId: string, feature: FeatureKey): Promise<boolean>;
+export declare function requireFeature(userId: string, feature: FeatureKey): Promise<boolean>;

package/dist/src/lib/billing/entitlements.js

@@ -0,0 +1,16 @@
+import { plans } from "./plans";
+import { getSubscription, isSubscriptionActive } from "./subscriptions";
+export async function hasFeature(userId, feature) {
+    const subscription = await getSubscription(userId);
+    if (!isSubscriptionActive(subscription)) {
+        return false;
+    }
+    return plans[subscription.plan].features.includes(feature);
+}
+export async function requireFeature(userId, feature) {
+    const allowed = await hasFeature(userId, feature);
+    if (!allowed) {
+        throw new Error(`Feature not available: ${feature}`);
+    }
+    return true;
+}

package/dist/src/lib/billing/events.d.ts

@@ -0,0 +1,12 @@
+import { type BillingAdapter } from "./adapters";
+export type BillingEventType = "subscription_created" | "payment_succeeded" | "payment_failed" | "subscription_updated" | "subscription_paused" | "subscription_canceled" | "portal_opened" | "repair_performed";
+export interface BillingEvent {
+    id: string;
+    userId: string;
+    type: BillingEventType;
+    createdAt: string;
+    metadata?: Record<string, unknown>;
+}
+export declare function setBillingEventAdapter(nextAdapter: BillingAdapter): void;
+export declare function recordBillingEvent(event: BillingEvent): Promise<BillingEvent>;
+export declare function getBillingEvents(userId: string): Promise<BillingEvent[]>;

package/dist/src/lib/billing/events.js

@@ -0,0 +1,20 @@
+import { memoryBillingAdapter, } from "./adapters";
+let adapter = memoryBillingAdapter;
+export function setBillingEventAdapter(nextAdapter) {
+    adapter = nextAdapter;
+}
+function requireEventAdapter() {
+    if (!adapter.recordBillingEvent ||
+        !adapter.getBillingEvents) {
+        throw new Error("Billing adapter does not support event operations");
+    }
+    return adapter;
+}
+export async function recordBillingEvent(event) {
+    return requireEventAdapter()
+        .recordBillingEvent(event);
+}
+export async function getBillingEvents(userId) {
+    return requireEventAdapter()
+        .getBillingEvents(userId);
+}

package/dist/src/lib/billing/plans.d.ts

@@ -0,0 +1,9 @@
+export type PlanId = "free" | "starter" | "pro" | "business";
+export type FeatureKey = "checkout" | "customer_portal" | "usage_limits" | "team_members" | "api_access" | "priority_support";
+export declare const plans: Record<PlanId, {
+    name: string;
+    monthlyLimit: number;
+    seatLimit: number;
+    features: FeatureKey[];
+}>;
+export declare function getPlanSeatLimit(plan: PlanId): number;

package/dist/src/lib/billing/plans.js

@@ -0,0 +1,41 @@
+export const plans = {
+    free: {
+        name: "Free",
+        monthlyLimit: 25,
+        seatLimit: 1,
+        features: ["checkout"],
+    },
+    starter: {
+        name: "Starter",
+        monthlyLimit: 500,
+        seatLimit: 1,
+        features: ["checkout", "customer_portal"],
+    },
+    pro: {
+        name: "Pro",
+        monthlyLimit: 5000,
+        seatLimit: 5,
+        features: [
+            "checkout",
+            "customer_portal",
+            "usage_limits",
+            "api_access",
+        ],
+    },
+    business: {
+        name: "Business",
+        monthlyLimit: 50000,
+        seatLimit: 25,
+        features: [
+            "checkout",
+            "customer_portal",
+            "usage_limits",
+            "team_members",
+            "api_access",
+            "priority_support",
+        ],
+    },
+};
+export function getPlanSeatLimit(plan) {
+    return plans[plan].seatLimit;
+}

package/dist/src/lib/billing/protection.d.ts

@@ -0,0 +1,6 @@
+import type { PlanId, FeatureKey } from "./plans";
+export declare function protectPlan(userId: string, plan: PlanId): Promise<import("./subscriptions").SubscriptionRecord>;
+export declare function protectFeature(userId: string, feature: FeatureKey): Promise<boolean>;
+export declare function protectUsage(userId: string, usageKey: string, amount?: number): Promise<{
+    allowed: boolean;
+}>;

package/dist/src/lib/billing/protection.js

@@ -0,0 +1,16 @@
+import { requireFeature } from "./entitlements";
+import { requireSubscription } from "./subscriptions";
+import { requireUsage, incrementUsage } from "./usage";
+export async function protectPlan(userId, plan) {
+    return requireSubscription(userId, plan);
+}
+export async function protectFeature(userId, feature) {
+    return requireFeature(userId, feature);
+}
+export async function protectUsage(userId, usageKey, amount = 1) {
+    await requireUsage(userId, usageKey);
+    await incrementUsage(userId, usageKey, amount);
+    return {
+        allowed: true,
+    };
+}

package/dist/src/lib/billing/refresh.d.ts

@@ -0,0 +1 @@
+export declare function refreshSubscriptionFromPaddle(subscriptionId: string): Promise<import("./subscriptions").SubscriptionRecord>;

package/dist/src/lib/billing/refresh.js

@@ -0,0 +1,32 @@
+import { upsertSubscription } from "./subscriptions";
+import { fetchPaddleSubscription } from "@/lib/paddle/subscriptions";
+function mapStatus(status) {
+    if (status === "active")
+        return "active";
+    if (status === "trialing")
+        return "trialing";
+    if (status === "paused")
+        return "paused";
+    if (status === "canceled")
+        return "canceled";
+    if (status === "past_due")
+        return "past_due";
+    return "none";
+}
+export async function refreshSubscriptionFromPaddle(subscriptionId) {
+    const response = await fetchPaddleSubscription(subscriptionId);
+    const sub = response.data;
+    const userId = sub?.custom_data?.userId;
+    if (!sub || !userId) {
+        throw new Error("Paddle subscription missing custom_data.userId");
+    }
+    const plan = sub.custom_data?.plan ?? "starter";
+    return upsertSubscription({
+        userId,
+        plan: plan,
+        status: mapStatus(sub.status),
+        paddleCustomerId: sub.customer_id,
+        paddleSubscriptionId: sub.id,
+        currentPeriodEnd: sub.current_billing_period?.ends_at,
+    });
+}

package/dist/src/lib/billing/subscriptions.d.ts

@@ -0,0 +1,16 @@
+import type { PlanId } from "./plans";
+import { type BillingAdapter } from "./adapters";
+export type SubscriptionStatus = "active" | "trialing" | "past_due" | "paused" | "canceled" | "expired" | "none";
+export interface SubscriptionRecord {
+    userId: string;
+    plan: PlanId;
+    status: SubscriptionStatus;
+    paddleCustomerId?: string;
+    paddleSubscriptionId?: string;
+    currentPeriodEnd?: string;
+}
+export declare function setBillingAdapter(nextAdapter: BillingAdapter): void;
+export declare function getSubscription(userId: string): Promise<SubscriptionRecord>;
+export declare function upsertSubscription(record: SubscriptionRecord): Promise<SubscriptionRecord>;
+export declare function isSubscriptionActive(subscription: SubscriptionRecord): boolean;
+export declare function requireSubscription(userId: string, minimumPlan?: PlanId): Promise<SubscriptionRecord>;

package/dist/src/lib/billing/subscriptions.js

@@ -0,0 +1,36 @@
+import { memoryBillingAdapter, } from "./adapters";
+let adapter = memoryBillingAdapter;
+export function setBillingAdapter(nextAdapter) {
+    adapter = nextAdapter;
+}
+export async function getSubscription(userId) {
+    return ((await adapter.getSubscription(userId)) ?? {
+        userId,
+        plan: "free",
+        status: "none",
+    });
+}
+export async function upsertSubscription(record) {
+    return adapter.upsertSubscription(record);
+}
+export function isSubscriptionActive(subscription) {
+    return (subscription.status === "active" ||
+        subscription.status === "trialing");
+}
+export async function requireSubscription(userId, minimumPlan = "starter") {
+    const subscription = await getSubscription(userId);
+    if (!isSubscriptionActive(subscription)) {
+        throw new Error("Active subscription required");
+    }
+    const order = [
+        "free",
+        "starter",
+        "pro",
+        "business",
+    ];
+    if (order.indexOf(subscription.plan) <
+        order.indexOf(minimumPlan)) {
+        throw new Error(`${minimumPlan} plan required`);
+    }
+    return subscription;
+}

package/dist/src/lib/billing/teams.d.ts

@@ -0,0 +1,42 @@
+import { type BillingAdapter } from "./adapters";
+import { type PlanId } from "./plans";
+export type TeamRole = "owner" | "admin" | "member";
+export interface TeamMember {
+    userId: string;
+    email?: string;
+    role: TeamRole;
+    joinedAt: string;
+}
+export interface TeamRecord {
+    teamId: string;
+    name: string;
+    plan: PlanId;
+    ownerId: string;
+    members: TeamMember[];
+}
+export declare function setTeamAdapter(nextAdapter: BillingAdapter): void;
+export declare function createTeam({ teamId, name, ownerId, plan, }: {
+    teamId: string;
+    name: string;
+    ownerId: string;
+    plan?: PlanId;
+}): Promise<TeamRecord>;
+export declare function getTeam(teamId: string): Promise<TeamRecord | null>;
+export declare function updateTeamPlan(teamId: string, plan: PlanId): Promise<TeamRecord>;
+export declare function getSeatUsage(teamId: string): Promise<{
+    used: number;
+    limit: number;
+    remaining: number;
+    allowed: boolean;
+}>;
+export declare function canInviteTeamMember(teamId: string): Promise<boolean>;
+export declare function addTeamMember({ teamId, userId, email, role, }: {
+    teamId: string;
+    userId: string;
+    email?: string;
+    role?: TeamRole;
+}): Promise<TeamRecord>;
+export declare function removeTeamMember({ teamId, userId, }: {
+    teamId: string;
+    userId: string;
+}): Promise<TeamRecord>;

package/dist/src/lib/billing/teams.js

@@ -0,0 +1,104 @@
+import { memoryBillingAdapter, } from "./adapters";
+import { getPlanSeatLimit } from "./plans";
+let adapter = memoryBillingAdapter;
+export function setTeamAdapter(nextAdapter) {
+    adapter = nextAdapter;
+}
+function requireTeamAdapter() {
+    if (!adapter.getTeam || !adapter.upsertTeam) {
+        throw new Error("Billing adapter does not support team operations");
+    }
+    return adapter;
+}
+export async function createTeam({ teamId, name, ownerId, plan = "free", }) {
+    const now = new Date().toISOString();
+    const team = {
+        teamId,
+        name,
+        ownerId,
+        plan,
+        members: [
+            {
+                userId: ownerId,
+                role: "owner",
+                joinedAt: now,
+            },
+        ],
+    };
+    return requireTeamAdapter()
+        .upsertTeam(team);
+}
+export async function getTeam(teamId) {
+    return requireTeamAdapter()
+        .getTeam(teamId);
+}
+export async function updateTeamPlan(teamId, plan) {
+    const team = await getTeam(teamId);
+    if (!team) {
+        throw new Error("Team not found");
+    }
+    team.plan = plan;
+    return requireTeamAdapter()
+        .upsertTeam(team);
+}
+export async function getSeatUsage(teamId) {
+    const team = await getTeam(teamId);
+    if (!team) {
+        throw new Error("Team not found");
+    }
+    const limit = getPlanSeatLimit(team.plan);
+    const used = team.members.length;
+    return {
+        used,
+        limit,
+        remaining: Math.max(0, limit - used),
+        allowed: used < limit,
+    };
+}
+export async function canInviteTeamMember(teamId) {
+    const usage = await getSeatUsage(teamId);
+    return usage.allowed;
+}
+export async function addTeamMember({ teamId, userId, email, role = "member", }) {
+    const team = await getTeam(teamId);
+    if (!team) {
+        throw new Error("Team not found");
+    }
+    const alreadyMember = team.members.some((member) => member.userId === userId);
+    if (alreadyMember) {
+        return team;
+    }
+    const usage = await getSeatUsage(teamId);
+    if (!usage.allowed) {
+        throw new Error("Seat limit reached");
+    }
+    const nextTeam = {
+        ...team,
+        members: [
+            ...team.members,
+            {
+                userId,
+                email,
+                role,
+                joinedAt: new Date().toISOString(),
+            },
+        ],
+    };
+    return requireTeamAdapter()
+        .upsertTeam(nextTeam);
+}
+export async function removeTeamMember({ teamId, userId, }) {
+    const team = await getTeam(teamId);
+    if (!team) {
+        throw new Error("Team not found");
+    }
+    if (team.ownerId === userId) {
+        throw new Error("Cannot remove team owner");
+    }
+    const nextTeam = {
+        ...team,
+        members: team.members.filter((member) => member.userId !== userId),
+    };
+    return requireTeamAdapter()
+        .upsertTeam(nextTeam);
+}

package/dist/src/lib/billing/usage.d.ts

@@ -0,0 +1,17 @@
+import { type BillingAdapter } from "./adapters";
+export declare function setUsageAdapter(nextAdapter: BillingAdapter): void;
+export declare function getUsage(userId: string, key: string): Promise<number>;
+export declare function getUsageLimit(userId: string): Promise<number>;
+export declare function canUse(userId: string, key: string): Promise<{
+    allowed: boolean;
+    used: number;
+    limit: number;
+    remaining: number;
+}>;
+export declare function incrementUsage(userId: string, key: string, amount?: number): Promise<number>;
+export declare function requireUsage(userId: string, key: string): Promise<{
+    allowed: boolean;
+    used: number;
+    limit: number;
+    remaining: number;
+}>;