@m5kdev/backend 0.1.0 → 0.1.2

package/dist/src/modules/billing/billing.repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"billing.repository.d.ts","sourceRoot":"","sources":["../../../../src/modules/billing/billing.repository.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gDAAgD,CAAC;AACpF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+CAA+C,CAAC;AAChF,OAAO,EAAiB,KAAK,gBAAgB,EAAW,MAAM,aAAa,CAAC;AAC5E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC9E,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAIpE,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/dist/src/modules/billing/billing.repository.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BillingRepository = void 0;
+const tslib_1 = require("tslib");
+const drizzle_orm_1 = require("drizzle-orm");
+const neverthrow_1 = require("neverthrow");
+const auth = tslib_1.__importStar(require("#modules/auth/auth.db"));
+const base_repository_1 = require("#modules/base/base.repository");
+const billing = tslib_1.__importStar(require("#modules/billing/billing.db"));
+const posthog_1 = require("#utils/posthog");
+const schema = { ...auth, ...billing };
+class BillingRepository extends base_repository_1.BaseTableRepository {
+    stripe;
+    plans;
+    trial;
+    constructor(options) {
+        const { libs, config, ...rest } = options;
+        super(rest);
+        this.stripe = libs.stripe;
+        this.plans = config.plans;
+        this.trial = config.trial;
+    }
+    hasTrial() {
+        return !!this.trial;
+    }
+    getPlanByPriceId(priceId) {
+        return this.plans.find((plan) => plan.priceId === priceId || plan.annualDiscountPriceId === priceId);
+    }
+    getCustomerByEmail(email) {
+        return this.throwableAsync(async () => {
+            const customers = await this.stripe.customers.list({
+                email,
+                limit: 1,
+            });
+            return (0, neverthrow_1.ok)(customers.data[0] ?? null);
+        });
+    }
+    getUserByCustomerId(customerId) {
+        return this.throwableAsync(async () => {
+            const [user] = await this.orm
+                .select()
+                .from(this.schema.users)
+                .where((0, drizzle_orm_1.eq)(this.schema.users.stripeCustomerId, customerId))
+                .limit(1);
+            return (0, neverthrow_1.ok)(user ?? null);
+        });
+    }
+    createCustomer({ email, name, userId, }) {
+        return this.throwableAsync(async () => {
+            const customer = await this.stripe.customers.create({
+                email,
+                name,
+                metadata: {
+                    userId,
+                },
+            });
+            return (0, neverthrow_1.ok)(customer);
+        });
+    }
+    async createTrialSubscription(customerId) {
+        if (!this.trial)
+            return this.error("NOT_FOUND", "Trial plan not found");
+        const stripeSubscription = await this.createSubscription({
+            customerId,
+            priceId: this.trial.priceId,
+            trialDays: this.trial.freeTrial?.days ?? 7,
+        });
+        if (stripeSubscription.isErr())
+            return (0, neverthrow_1.err)(stripeSubscription.error);
+        if (!stripeSubscription.value)
+            return this.error("INTERNAL_SERVER_ERROR", "Failed to create trial subscription");
+        return (0, neverthrow_1.ok)(stripeSubscription.value);
+    }
+    createSubscription({ customerId, priceId, quantity = 1, trialDays, }) {
+        return this.throwableAsync(async () => {
+            const stripeSubscription = await this.stripe.subscriptions.create({
+                customer: customerId,
+                items: [{ price: priceId, quantity }], // quantity = seats if you want
+                ...(trialDays
+                    ? {
+                        trial_period_days: trialDays,
+                        trial_settings: {
+                            end_behavior: {
+                                missing_payment_method: "cancel",
+                            },
+                        },
+                    }
+                    : {}),
+            });
+            return (0, neverthrow_1.ok)(stripeSubscription);
+        });
+    }
+    updateUserCustomerId({ userId, customerId, }) {
+        return this.throwableAsync(async () => {
+            const [user] = await this.orm
+                .update(this.schema.users)
+                .set({ stripeCustomerId: customerId })
+                .where((0, drizzle_orm_1.eq)(this.schema.users.id, userId))
+                .returning();
+            if (!user)
+                return this.error("NOT_FOUND", "User not found");
+            return (0, neverthrow_1.ok)(user);
+        });
+    }
+    getLatestSubscription(referenceId) {
+        return this.throwableAsync(async () => {
+            const subscriptions = await this.orm
+                .select()
+                .from(this.schema.subscriptions)
+                .where((0, drizzle_orm_1.eq)(this.schema.subscriptions.referenceId, referenceId))
+                .orderBy((0, drizzle_orm_1.desc)(this.schema.subscriptions.createdAt))
+                .limit(1);
+            return (0, neverthrow_1.ok)(subscriptions[0] ?? null);
+        });
+    }
+    getActiveSubscription(referenceId) {
+        return this.throwableAsync(async () => {
+            const [subscription] = await this.orm
+                .select()
+                .from(this.schema.subscriptions)
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(this.schema.subscriptions.referenceId, referenceId), (0, drizzle_orm_1.inArray)(this.schema.subscriptions.status, ["active", "trialing"])))
+                .orderBy((0, drizzle_orm_1.desc)(this.schema.subscriptions.createdAt))
+                .limit(1);
+            return (0, neverthrow_1.ok)(subscription ?? null);
+        });
+    }
+    listInvoices(customerId) {
+        return this.throwableAsync(async () => {
+            const invoices = await this.stripe.invoices.list({
+                customer: customerId,
+            });
+            return (0, neverthrow_1.ok)(invoices.data);
+        });
+    }
+    createCheckoutSession({ customerId, priceId, userId, }) {
+        return this.throwableAsync(async () => {
+            const session = await this.stripe.checkout.sessions.create({
+                client_reference_id: userId,
+                customer: customerId,
+                success_url: `${process.env.VITE_SERVER_URL}/stripe/success`,
+                cancel_url: `${process.env.VITE_APP_URL}/billing`,
+                mode: "subscription",
+                line_items: [
+                    {
+                        price: priceId,
+                        quantity: 1,
+                    },
+                ],
+            });
+            return (0, neverthrow_1.ok)(session);
+        });
+    }
+    createBillingPortalSession(customerId) {
+        return this.throwableAsync(async () => {
+            const session = await this.stripe.billingPortal.sessions.create({
+                customer: customerId,
+                return_url: `${process.env.VITE_SERVER_URL}/stripe/success`,
+            });
+            return (0, neverthrow_1.ok)(session);
+        });
+    }
+    async syncStripeData({ customerId, userId, }) {
+        return this.throwableAsync(async () => {
+            // Fetch latest subscription data from Stripe
+            const stripeSubscriptions = await this.stripe.subscriptions.list({
+                customer: customerId,
+                limit: 1,
+                status: "all",
+                expand: ["data.default_payment_method"],
+            });
+            const [stripeSubscription] = stripeSubscriptions.data;
+            if (!stripeSubscription)
+                return this.error("NOT_FOUND", "Subscription not found");
+            const plan = this.getPlanByPriceId(stripeSubscription.items.data[0]?.price.id);
+            if (!plan)
+                return this.error("NOT_FOUND", `Plan not found for price ID: ${stripeSubscription.items.data[0]?.price.id}`);
+            const values = {
+                stripeCustomerId: customerId,
+                referenceId: userId,
+                plan: plan.name,
+                status: stripeSubscription.status,
+                seats: stripeSubscription.items.data[0]?.quantity || 1,
+                periodEnd: new Date(stripeSubscription.items.data[0]?.current_period_end * 1000),
+                periodStart: new Date(stripeSubscription.items.data[0]?.current_period_start * 1000),
+                priceId: stripeSubscription.items.data[0]?.price.id,
+                interval: stripeSubscription.items.data[0]?.price.recurring?.interval,
+                unitAmount: stripeSubscription.items.data[0]?.price.unit_amount,
+                discounts: stripeSubscription.discounts.map((discount) => typeof discount === "string" ? discount : discount.id),
+                stripeSubscriptionId: stripeSubscription.id,
+                cancelAtPeriodEnd: stripeSubscription.cancel_at_period_end,
+                cancelAt: stripeSubscription.cancel_at
+                    ? new Date(stripeSubscription.cancel_at * 1000)
+                    : null,
+                canceledAt: stripeSubscription.canceled_at
+                    ? new Date(stripeSubscription.canceled_at * 1000)
+                    : null,
+                ...(stripeSubscription.trial_start && stripeSubscription.trial_end
+                    ? {
+                        trialStart: new Date(stripeSubscription.trial_start * 1000),
+                        trialEnd: new Date(stripeSubscription.trial_end * 1000),
+                    }
+                    : {}),
+            };
+            const existingSubscription = await this.getActiveSubscription(userId);
+            if (existingSubscription.isErr())
+                return (0, neverthrow_1.err)(existingSubscription.error);
+            if (!existingSubscription.value) {
+                await this.orm.insert(this.schema.subscriptions).values(values);
+                (0, posthog_1.posthogCapture)({
+                    distinctId: userId,
+                    event: "stripe.subscription_created",
+                    properties: values,
+                });
+                return (0, neverthrow_1.ok)(true);
+            }
+            await this.orm
+                .update(this.schema.subscriptions)
+                .set({ ...values, updatedAt: new Date() })
+                .where((0, drizzle_orm_1.eq)(this.schema.subscriptions.id, existingSubscription.value.id));
+            (0, posthog_1.posthogCapture)({
+                distinctId: userId,
+                event: "stripe.subscription_updated",
+                properties: values,
+            });
+            return (0, neverthrow_1.ok)(false);
+        });
+    }
+    constructEvent(body, signature, secret) {
+        return this.throwable(() => {
+            const event = this.stripe.webhooks.constructEvent(body, signature, secret);
+            return (0, neverthrow_1.ok)(event);
+        });
+    }
+}
+exports.BillingRepository = BillingRepository;

package/dist/src/modules/billing/billing.router.d.ts

@@ -0,0 +1,5 @@
+import { Router } from "express";
+import type { AuthMiddleware } from "#modules/auth/auth.middleware";
+import type { BillingService } from "#modules/billing/billing.service";
+export declare function createBillingRouter(authMiddleware: AuthMiddleware, service: BillingService): Router;
+//# sourceMappingURL=billing.router.d.ts.map

package/dist/src/modules/billing/billing.router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"billing.router.d.ts","sourceRoot":"","sources":["../../../../src/modules/billing/billing.router.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAEvE,wBAAgB,mBAAmB,CACjC,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE,cAAc,GACtB,MAAM,CAoER"}

package/dist/src/modules/billing/billing.router.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBillingRouter = createBillingRouter;
+const tslib_1 = require("tslib");
+const body_parser_1 = tslib_1.__importDefault(require("body-parser"));
+const express_1 = require("express");
+function createBillingRouter(authMiddleware, service) {
+    const billingRouter = (0, express_1.Router)();
+    billingRouter.get("/checkout/:priceId", authMiddleware, async (req, res) => {
+        const user = req.user;
+        const session = await service.createCheckoutSession({ priceId: req.params.priceId }, { user });
+        if (session.isErr()) {
+            return res.status(500).json({ message: session.error.message });
+        }
+        if (!session.value.url) {
+            return res.status(500).json({ message: "Failed to create checkout session" });
+        }
+        return res.redirect(session.value.url);
+    });
+    billingRouter.get("/portal", authMiddleware, async (req, res) => {
+        const user = req.user;
+        const session = await service.createBillingPortalSession({ user });
+        if (session.isErr()) {
+            return res.status(500).json({ message: session.error.message });
+        }
+        return res.redirect(session.value.url);
+    });
+    billingRouter.get("/success", authMiddleware, async (req, res) => {
+        const user = req.user;
+        if (!user.stripeCustomerId) {
+            return res.redirect(`${process.env.VITE_APP_URL}/billing`);
+        }
+        const result = await service.syncStripeData(user.stripeCustomerId);
+        if (result.isErr()) {
+            return res.redirect(`${process.env.VITE_APP_URL}/billing?error=SYNC_FAILED`);
+        }
+        return res.redirect(`${process.env.VITE_APP_URL}/billing`);
+    });
+    billingRouter.post("/webhook", body_parser_1.default.raw({ type: "application/json" }), async (req, res) => {
+        const signature = req.headers["stripe-signature"];
+        if (!signature)
+            return res.status(400).json({ message: "No signature" });
+        if (typeof signature !== "string")
+            return res.status(500).json({ message: "Signature is not a string" });
+        const event = service.constructEvent(req.body, signature);
+        if (event.isErr()) {
+            return res.status(500).json({ message: event.error.message });
+        }
+        const result = await service.processEvent(event.value);
+        if (result.isErr()) {
+            return res.status(500).json({ message: result.error.message });
+        }
+        return res.status(200).json({ received: true });
+    });
+    return billingRouter;
+}

package/dist/src/modules/billing/billing.service.d.ts

@@ -0,0 +1,60 @@
+import type Stripe from "stripe";
+import type { User } from "#modules/auth/auth.lib";
+import type { ServerResult, ServerResultAsync } from "#modules/base/base.dto";
+import { BaseService } from "#modules/base/base.service";
+import type { BillingRepository } from "#modules/billing/billing.repository";
+export declare class BillingService extends BaseService<{
+    billing: BillingRepository;
+}, never> {
+    createUserCustomer({ user, }: {
+        user: {
+            id: string;
+            email: string;
+            name?: string;
+        };
+    }): ServerResultAsync<Stripe.Customer>;
+    createUserHook({ user, }: {
+        user: {
+            id: string;
+            email: string;
+            name?: string;
+        };
+    }): ServerResultAsync<boolean>;
+    getActiveSubscription({ user }: {
+        user: User;
+    }): Promise<ServerResult<{
+        id: string;
+        plan: string;
+        referenceId: string;
+        status: string;
+        stripeCustomerId?: string | null | undefined;
+        stripeSubscriptionId?: string | null | undefined;
+        periodStart?: Date | null | undefined;
+        periodEnd?: Date | null | undefined;
+        cancelAtPeriodEnd?: boolean | null | undefined;
+        cancelAt?: Date | null | undefined;
+        canceledAt?: Date | null | undefined;
+        seats?: number | null | undefined;
+        trialStart?: Date | null | undefined;
+        trialEnd?: Date | null | undefined;
+        priceId?: string | null | undefined;
+        interval?: string | null | undefined;
+        unitAmount?: number | null | undefined;
+        discounts?: string[] | null | undefined;
+    } | null>>;
+    listInvoices({ user }: {
+        user: User;
+    }): ServerResultAsync<Stripe.Invoice[]>;
+    createCheckoutSession({ priceId }: {
+        priceId: string;
+    }, { user }: {
+        user: User;
+    }): ServerResultAsync<Stripe.Checkout.Session>;
+    createBillingPortalSession({ user, }: {
+        user: User;
+    }): ServerResultAsync<Stripe.BillingPortal.Session>;
+    constructEvent(body: Buffer | string, signature: string): ServerResult<Stripe.Event>;
+    syncStripeData(customerId: string, eventType?: string): ServerResultAsync<boolean>;
+    processEvent(event: Stripe.Event): ServerResultAsync<boolean>;
+}
+//# sourceMappingURL=billing.service.d.ts.map

package/dist/src/modules/billing/billing.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"billing.service.d.ts","sourceRoot":"","sources":["../../../../src/modules/billing/billing.service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AACjC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAyB7E,qBAAa,cAAe,SAAQ,WAAW,CAAC;IAAE,OAAO,EAAE,iBAAiB,CAAA;CAAE,EAAE,KAAK,CAAC;IAC9E,kBAAkB,CAAC,EACvB,IAAI,GACL,EAAE;QACD,IAAI,EAAE;YAAE,EAAE,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;KACpD,GAAG,iBAAiB,CAAC,MAAM,CAAC,QAAQ,CAAC;IAyBhC,cAAc,CAAC,EACnB,IAAI,GACL,EAAE;QACD,IAAI,EAAE;YAAE,EAAE,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;KACpD,GAAG,iBAAiB,CAAC,OAAO,CAAC;IAsBxB,qBAAqB,CAAC,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;IAI9C,YAAY,CAAC,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE,GAAG,iBAAiB,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;IAK3E,qBAAqB,CACzB,EAAE,OAAO,EAAE,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,EAChC,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE,GACvB,iBAAiB,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC;IAcvC,0BAA0B,CAAC,EAC/B,IAAI,GACL,EAAE;QACD,IAAI,EAAE,IAAI,CAAC;KACZ,GAAG,iBAAiB,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC;IAUnD,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC,KAAK,CAAC;IAU9E,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,iBAAiB,CAAC,OAAO,CAAC;IAiBlF,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,GAAG,iBAAiB,CAAC,OAAO,CAAC;CAuBpE"}

package/dist/src/modules/billing/billing.service.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BillingService = void 0;
+const neverthrow_1 = require("neverthrow");
+const base_service_1 = require("#modules/base/base.service");
+const posthog_1 = require("#utils/posthog");
+const allowedEvents = [
+    "checkout.session.completed",
+    "customer.subscription.created",
+    "customer.subscription.updated",
+    "customer.subscription.deleted",
+    "customer.subscription.paused",
+    "customer.subscription.resumed",
+    "customer.subscription.pending_update_applied",
+    "customer.subscription.pending_update_expired",
+    "customer.subscription.trial_will_end",
+    "invoice.paid",
+    "invoice.payment_failed",
+    "invoice.payment_action_required",
+    "invoice.upcoming",
+    "invoice.marked_uncollectible",
+    "invoice.payment_succeeded",
+    "payment_intent.succeeded",
+    "payment_intent.payment_failed",
+    "payment_intent.canceled",
+];
+class BillingService extends base_service_1.BaseService {
+    async createUserCustomer({ user, }) {
+        let stripeCustomer = null;
+        const existingCustomer = await this.repository.billing.getCustomerByEmail(user.email);
+        if (existingCustomer.isErr())
+            return (0, neverthrow_1.err)(existingCustomer.error);
+        stripeCustomer = existingCustomer.value;
+        if (!stripeCustomer) {
+            const newCustomer = await this.repository.billing.createCustomer({
+                email: user.email,
+                name: user.name,
+                userId: user.id,
+            });
+            if (newCustomer.isErr())
+                return (0, neverthrow_1.err)(newCustomer.error);
+            stripeCustomer = newCustomer.value;
+        }
+        if (!stripeCustomer)
+            return this.error("INTERNAL_SERVER_ERROR", "Failed to create or get stripe customer");
+        const updatedUser = await this.repository.billing.updateUserCustomerId({
+            userId: user.id,
+            customerId: stripeCustomer.id,
+        });
+        if (updatedUser.isErr())
+            return (0, neverthrow_1.err)(updatedUser.error);
+        return (0, neverthrow_1.ok)(stripeCustomer);
+    }
+    async createUserHook({ user, }) {
+        const stripeCustomer = await this.createUserCustomer({ user });
+        if (stripeCustomer.isErr())
+            return (0, neverthrow_1.err)(stripeCustomer.error);
+        if (this.repository.billing.hasTrial()) {
+            const existingSubscription = await this.repository.billing.getLatestSubscription(user.id);
+            if (existingSubscription.isErr())
+                return (0, neverthrow_1.err)(existingSubscription.error);
+            if (!existingSubscription.value) {
+                const subscription = await this.repository.billing.createTrialSubscription(stripeCustomer.value.id);
+                if (subscription.isErr())
+                    return (0, neverthrow_1.err)(subscription.error);
+            }
+            const syncResult = await this.syncStripeData(stripeCustomer.value.id);
+            if (syncResult.isErr())
+                return (0, neverthrow_1.err)(syncResult.error);
+            if (syncResult.value === false)
+                return this.error("INTERNAL_SERVER_ERROR", "Sync did not create new subscription");
+        }
+        return (0, neverthrow_1.ok)(true);
+    }
+    async getActiveSubscription({ user }) {
+        return this.repository.billing.getActiveSubscription(user.id);
+    }
+    async listInvoices({ user }) {
+        if (!user.stripeCustomerId)
+            return this.error("NOT_FOUND", "User has no stripe customer id");
+        return this.repository.billing.listInvoices(user.stripeCustomerId);
+    }
+    async createCheckoutSession({ priceId }, { user }) {
+        let stripeCustomerId = user.stripeCustomerId;
+        if (!stripeCustomerId) {
+            const stripeCustomer = await this.createUserCustomer({ user });
+            if (stripeCustomer.isErr())
+                return (0, neverthrow_1.err)(stripeCustomer.error);
+            stripeCustomerId = stripeCustomer.value.id;
+        }
+        return this.repository.billing.createCheckoutSession({
+            customerId: stripeCustomerId,
+            priceId,
+            userId: user.id,
+        });
+    }
+    async createBillingPortalSession({ user, }) {
+        let stripeCustomerId = user.stripeCustomerId;
+        if (!stripeCustomerId) {
+            const stripeCustomer = await this.createUserCustomer({ user });
+            if (stripeCustomer.isErr())
+                return (0, neverthrow_1.err)(stripeCustomer.error);
+            stripeCustomerId = stripeCustomer.value.id;
+        }
+        return this.repository.billing.createBillingPortalSession(stripeCustomerId);
+    }
+    constructEvent(body, signature) {
+        if (!process.env.STRIPE_WEBHOOK_SECRET)
+            return this.error("INTERNAL_SERVER_ERROR", "Stripe webhook secret is not set");
+        return this.repository.billing.constructEvent(body, signature, process.env.STRIPE_WEBHOOK_SECRET);
+    }
+    async syncStripeData(customerId, eventType) {
+        const user = await this.repository.billing.getUserByCustomerId(customerId);
+        if (user.isErr())
+            return (0, neverthrow_1.err)(user.error);
+        if (!user.value)
+            return this.error("NOT_FOUND", "User not found");
+        if (eventType) {
+            (0, posthog_1.posthogCapture)({
+                distinctId: user.value.id,
+                event: `stripe.${eventType}`,
+                properties: {
+                    customerId,
+                },
+            });
+        }
+        return this.repository.billing.syncStripeData({ customerId, userId: user.value.id });
+    }
+    async processEvent(event) {
+        return this.throwableAsync(async () => {
+            // Skip processing if the event isn't one I'm tracking (list of all events below)
+            if (!allowedEvents.includes(event.type))
+                return (0, neverthrow_1.ok)(false);
+            // All the events I track have a customerId
+            const { customer: customerId } = event?.data?.object;
+            // This helps make it typesafe and also lets me know if my assumption is wrong
+            if (typeof customerId !== "string") {
+                return this.error("INTERNAL_SERVER_ERROR", `[STRIPE HOOK] Unexpected event structure: customer ID is not a string. Event type: ${event.type}`);
+            }
+            const result = await this.syncStripeData(customerId, event.type);
+            if (result.isErr())
+                return (0, neverthrow_1.err)(result.error);
+            return (0, neverthrow_1.ok)(true);
+        });
+    }
+}
+exports.BillingService = BillingService;

package/dist/src/modules/billing/billing.trpc.d.ts

@@ -0,0 +1,75 @@
+import type { BillingService } from "#modules/billing/billing.service";
+export declare function createBillingTRPC(billingService: BillingService): import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        session: {
+            id: string;
+            userId: string;
+            updatedAt: Date;
+            createdAt: Date;
+            expiresAt: Date;
+            token: string;
+            ipAddress: string | null;
+            userAgent: string | null;
+            impersonatedBy: string | null;
+            activeOrganizationId: string | null;
+            activeOrganizationRole: string | null;
+            activeTeamId: string | null;
+            activeTeamRole: string | null;
+        };
+        user: {
+            name: string;
+            id: string;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            image: string | null;
+            createdAt: Date;
+            role: string | null;
+            banned: boolean | null;
+            banReason: string | null;
+            banExpires: Date | null;
+            stripeCustomerId: string | null;
+            paymentCustomerId: string | null;
+            paymentPlanTier: string | null;
+            paymentPlanExpiresAt: Date | null;
+            preferences: string | null;
+            metadata: Record<string, unknown>;
+            onboarding: number | null;
+            flags: string | null;
+        };
+    };
+    meta: import("trpc-to-openapi").OpenApiMeta;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: true;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    getActiveSubscription: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            id: string;
+            plan: string;
+            referenceId: string;
+            status: string;
+            stripeCustomerId?: string | null | undefined;
+            stripeSubscriptionId?: string | null | undefined;
+            periodStart?: Date | null | undefined;
+            periodEnd?: Date | null | undefined;
+            cancelAtPeriodEnd?: boolean | null | undefined;
+            cancelAt?: Date | null | undefined;
+            canceledAt?: Date | null | undefined;
+            seats?: number | null | undefined;
+            trialStart?: Date | null | undefined;
+            trialEnd?: Date | null | undefined;
+            priceId?: string | null | undefined;
+            interval?: string | null | undefined;
+            unitAmount?: number | null | undefined;
+            discounts?: string[] | null | undefined;
+        } | null;
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    listInvoices: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: import("stripe").Stripe.Invoice[];
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+}>>;
+//# sourceMappingURL=billing.trpc.d.ts.map

package/dist/src/modules/billing/billing.trpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"billing.trpc.d.ts","sourceRoot":"","sources":["../../../../src/modules/billing/billing.trpc.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAGvE,wBAAgB,iBAAiB,CAAC,cAAc,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAY/D"}

package/dist/src/modules/billing/billing.trpc.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBillingTRPC = createBillingTRPC;
+const billing_schema_1 = require("@m5kdev/commons/modules/billing/billing.schema");
+const _trpc_1 = require("#trpc");
+function createBillingTRPC(billingService) {
+    return (0, _trpc_1.router)({
+        getActiveSubscription: _trpc_1.procedure
+            .output(billing_schema_1.billingSchema.nullable())
+            .query(async ({ ctx: { user } }) => {
+            return (0, _trpc_1.handleTRPCResult)(await billingService.getActiveSubscription({ user }));
+        }),
+        listInvoices: _trpc_1.procedure.query(async ({ ctx: { user } }) => {
+            return (0, _trpc_1.handleTRPCResult)(await billingService.listInvoices({ user }));
+        }),
+    });
+}

package/dist/src/modules/clay/clay.repository.d.ts

@@ -0,0 +1,6 @@
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseExternaRepository } from "#modules/base/base.repository";
+export declare class ClayRepository extends BaseExternaRepository {
+    sendToWebhook(webhookUrl: string, row: Record<string, unknown>, callbackUrl: string): ServerResultAsync<void>;
+}
+//# sourceMappingURL=clay.repository.d.ts.map

package/dist/src/modules/clay/clay.repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clay.repository.d.ts","sourceRoot":"","sources":["../../../../src/modules/clay/clay.repository.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAItE,qBAAa,cAAe,SAAQ,qBAAqB;IACjD,aAAa,CACjB,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,WAAW,EAAE,MAAM,GAClB,iBAAiB,CAAC,IAAI,CAAC;CAiB3B"}

package/dist/src/modules/clay/clay.repository.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClayRepository = void 0;
+const neverthrow_1 = require("neverthrow");
+const base_repository_1 = require("#modules/base/base.repository");
+const { CLAY_WEBHOOK_AUTH_TOKEN } = process.env;
+class ClayRepository extends base_repository_1.BaseExternaRepository {
+    async sendToWebhook(webhookUrl, row, callbackUrl) {
+        return this.throwableAsync(async () => {
+            const response = await fetch(webhookUrl, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...(CLAY_WEBHOOK_AUTH_TOKEN ? { "x-clay-webhook-auth": CLAY_WEBHOOK_AUTH_TOKEN } : {}),
+                },
+                body: JSON.stringify({ ...row, callback: callbackUrl }),
+            });
+            if (!response.ok)
+                return this.error("BAD_REQUEST", `HTTP error! status: ${response.status}`, {
+                    cause: response,
+                });
+            return (0, neverthrow_1.ok)();
+        });
+    }
+}
+exports.ClayRepository = ClayRepository;