@m5kdev/backend 0.6.0 → 0.8.0

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

@@ -1,235 +0,0 @@
-"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("../auth/auth.db"));
-const base_repository_1 = require("../base/base.repository");
-const billing = tslib_1.__importStar(require("./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

@@ -1,4 +0,0 @@
-import { Router } from "express";
-import type { AuthMiddleware } from "../auth/auth.middleware";
-import type { BillingService } from "./billing.service";
-export declare function createBillingRouter(authMiddleware: AuthMiddleware, service: BillingService): Router;

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

@@ -1,56 +0,0 @@
-"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

@@ -1,59 +0,0 @@
-import type Stripe from "stripe";
-import type { User } from "../auth/auth.lib";
-import type { ServerResult, ServerResultAsync } from "../base/base.dto";
-import { BaseService } from "../base/base.service";
-import type { BillingRepository } from "./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>;
-}

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

@@ -1,147 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BillingService = void 0;
-const neverthrow_1 = require("neverthrow");
-const base_service_1 = require("../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

@@ -1,38 +0,0 @@
-import type { BillingService } from "./billing.service";
-import { type TRPCMethods } from "../../utils/trpc";
-export declare function createBillingTRPC({ router, privateProcedure: procedure }: TRPCMethods, billingService: BillingService): import("@trpc/server").TRPCBuiltRouter<{
-    ctx: import("../auth/auth.lib").Context;
-    meta: any;
-    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: any;
-    }>;
-    listInvoices: import("@trpc/server").TRPCQueryProcedure<{
-        input: void;
-        output: import("stripe").Stripe.Invoice[];
-        meta: any;
-    }>;
-}>>;

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

@@ -1,17 +0,0 @@
-"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("../../utils/trpc");
-function createBillingTRPC({ router, privateProcedure: procedure }, billingService) {
-    return router({
-        getActiveSubscription: procedure
-            .output(billing_schema_1.billingSchema.nullable())
-            .query(async ({ ctx: { user } }) => {
-            return (0, trpc_1.handleTRPCResult)(await billingService.getActiveSubscription({ user }));
-        }),
-        listInvoices: procedure.query(async ({ ctx: { user } }) => {
-            return (0, trpc_1.handleTRPCResult)(await billingService.listInvoices({ user }));
-        }),
-    });
-}

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

@@ -1,5 +0,0 @@
-import type { ServerResultAsync } from "../base/base.dto";
-import { BaseExternaRepository } from "../base/base.repository";
-export declare class ClayRepository extends BaseExternaRepository {
-    sendToWebhook(webhookUrl: string, row: Record<string, unknown>, callbackUrl: string): ServerResultAsync<void>;
-}

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

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClayRepository = void 0;
-const neverthrow_1 = require("neverthrow");
-const base_repository_1 = require("../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;

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

@@ -1,28 +0,0 @@
-import type { z } from "zod";
-import type { ServerResultAsync } from "../base/base.dto";
-import { BaseService } from "../base/base.service";
-import type { WebhookService } from "../webhook/webhook.service";
-import type { ClayRepository } from "./clay.repository";
-type ClayTable = {
-    name?: string;
-    tableId?: string;
-    viewId?: string;
-    webhookUrl: string;
-    schema?: z.ZodAny;
-    timeoutInSeconds?: number;
-};
-export declare class ClayService<K extends string> extends BaseService<{
-    clay: ClayRepository;
-}, {
-    webhook: WebhookService;
-}> {
-    private tables;
-    constructor(repositories: {
-        clay: ClayRepository;
-    }, services: {
-        webhook: WebhookService;
-    }, tables: Record<K, ClayTable>);
-    waitForResponse<T>(webhookUrl: string, row: Record<string, unknown>, timeoutInSeconds?: number): ServerResultAsync<T>;
-    sendToTable(table: K, row: Record<string, unknown>, timeoutInSeconds?: number): ServerResultAsync<z.infer<(typeof this.tables)[K]["schema"] extends z.ZodAny ? z.infer<(typeof this.tables)[K]["schema"]> : unknown>>;
-}
-export {};

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

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClayService = void 0;
-const base_service_1 = require("../base/base.service");
-class ClayService extends base_service_1.BaseService {
-    tables;
-    constructor(repositories, services, tables) {
-        super(repositories, services);
-        this.tables = tables;
-    }
-    async waitForResponse(webhookUrl, row, timeoutInSeconds) {
-        return await this.service.webhook.waitForRequest((url) => {
-            return this.repository.clay.sendToWebhook(webhookUrl, row, url);
-        }, timeoutInSeconds);
-    }
-    async sendToTable(table, row, timeoutInSeconds) {
-        const tableData = this.tables[table];
-        if (!tableData)
-            return this.error("NOT_FOUND", `Table ${table} not found`);
-        const response = await this.waitForResponse(tableData.webhookUrl, row, tableData.timeoutInSeconds || timeoutInSeconds);
-        return response;
-    }
-}
-exports.ClayService = ClayService;