@m5kdev/backend 0.1.1 → 0.1.2

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

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseExternaRepository = exports.BaseTableRepository = exports.BaseRepository = exports.arrayContains = exports.TableConditionBuilder = exports.ConditionBuilder = void 0;
+const drizzle_orm_1 = require("drizzle-orm");
+const neverthrow_1 = require("neverthrow");
+const base_abstract_1 = require("#modules/base/base.abstract");
+const base_dto_1 = require("#modules/base/base.dto");
+const applyPagination_1 = require("#modules/utils/applyPagination");
+const applySorting_1 = require("#modules/utils/applySorting");
+const getConditionsFromFilters_1 = require("#modules/utils/getConditionsFromFilters");
+class ConditionBuilder {
+    conditions;
+    constructor(conditions = []) {
+        this.conditions = conditions;
+        this.conditions = conditions;
+    }
+    push(condition) {
+        if (condition)
+            this.conditions.push(condition);
+    }
+    join(type = "and") {
+        if (this.conditions.length === 0)
+            return undefined;
+        if (this.conditions.length === 1)
+            return this.conditions[0];
+        return type === "and" ? (0, drizzle_orm_1.and)(...this.conditions) : (0, drizzle_orm_1.or)(...this.conditions);
+    }
+    [Symbol.iterator]() {
+        return this.conditions[Symbol.iterator]();
+    }
+}
+exports.ConditionBuilder = ConditionBuilder;
+class TableConditionBuilder extends ConditionBuilder {
+    table;
+    constructor(table) {
+        super();
+        this.table = table;
+    }
+    applyFilters({ filters } = {}) {
+        if (filters && filters.length > 0)
+            (0, getConditionsFromFilters_1.getConditionsFromFilters)(this, filters, this.table);
+    }
+}
+exports.TableConditionBuilder = TableConditionBuilder;
+const arrayContains = (table, values) => {
+    const arrayContains = [];
+    for (const value of values) {
+        arrayContains.push((0, drizzle_orm_1.like)(table, `%"${value}%"`));
+    }
+    return (0, drizzle_orm_1.or)(...arrayContains);
+};
+exports.arrayContains = arrayContains;
+class BaseRepository extends base_abstract_1.Base {
+    orm;
+    schema;
+    repository;
+    constructor(options, repository) {
+        super("repository");
+        this.orm = options.orm;
+        this.schema = options.schema;
+        this.repository = repository;
+    }
+    getConditionBuilder(table) {
+        if (table === undefined) {
+            return new ConditionBuilder();
+        }
+        return new TableConditionBuilder(table);
+    }
+    withPagination(query, { page, limit }) {
+        return (0, applyPagination_1.applyPagination)(query, limit, page);
+    }
+    withSorting(query, { sort, order }, table) {
+        if (!table)
+            throw new Error("No table provided");
+        return (0, applySorting_1.applySorting)(query, table, sort, order);
+    }
+    withSortingAndPagination(query, { sort, order, page, limit }, table) {
+        if (!table)
+            throw new Error("No table provided");
+        return this.withSorting(this.withPagination(query, { page, limit }), { sort, order }, table);
+    }
+    addUserIdFilter(userId, query) {
+        const userIdFilter = {
+            columnId: "userId",
+            type: "string",
+            method: "equals",
+            value: userId,
+        };
+        return query
+            ? { ...query, filters: [...(query?.filters ?? []), userIdFilter] }
+            : { filters: [userIdFilter] };
+    }
+    helpers = {
+        pickColumns: base_dto_1.pickColumns,
+        arrayContains: exports.arrayContains,
+        ConditionBuilder,
+    };
+}
+exports.BaseRepository = BaseRepository;
+/**
+ * Generic table-bound repository with typed CRUD, returning ServerResultAsync via throwableAsync.
+ *
+ * Example:
+ * const userRepo = new UserRepository(db, schema);
+ * class UserRepository extends BaseTableRepository<typeof schema.user> {
+ *   constructor(db: LibSQLDatabase<typeof schema>, schema: typeof schema) {
+ *     super(db, schema, schema.user);
+ *   }
+ * }
+ */
+class BaseTableRepository extends BaseRepository {
+    table;
+    idKey;
+    idColumn;
+    constructor(options, repository) {
+        super({ orm: options.orm, schema: options.schema }, repository);
+        this.table = options.table;
+        this.idKey = options.idKey ?? "id";
+        this.idColumn = this.table[this.idKey];
+    }
+    withSorting(query, { sort, order }, table) {
+        return super.withSorting(query, { sort, order }, table || this.table);
+    }
+    withSortingAndPagination(query, { sort, order, page, limit }, table) {
+        return super.withSortingAndPagination(query, { sort, order, page, limit }, table || this.table);
+    }
+    async queryList(query, options, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            const conditions = options?.conditions ?? this.getConditionBuilder(this.table);
+            conditions.applyFilters(query);
+            const whereClause = conditions.join();
+            const rowsQuery = this.withSortingAndPagination((options?.select ? db.select(options.select) : db.select())
+                .from(this.table)
+                .where(whereClause), query || {});
+            const countQuery = db
+                .select({ count: (0, drizzle_orm_1.count)() })
+                .from(this.table)
+                .where(whereClause);
+            const [rows, [totalResult]] = await Promise.all([rowsQuery, countQuery]);
+            return (0, neverthrow_1.ok)({ rows: rows, total: totalResult?.count ?? 0 });
+        });
+    }
+    async findById(id, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            const rows = (await db
+                .select()
+                .from(this.table)
+                .where((0, drizzle_orm_1.eq)(this.idColumn, id)));
+            return (0, neverthrow_1.ok)(rows[0]);
+        });
+    }
+    async findManyById(ids, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            if (ids.length === 0) {
+                return (0, neverthrow_1.ok)([]);
+            }
+            const rows = (await db
+                .select()
+                .from(this.table)
+                .where((0, drizzle_orm_1.inArray)(this.idColumn, ids)));
+            return (0, neverthrow_1.ok)(rows);
+        });
+    }
+    async create(data, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            const rows = (await db
+                .insert(this.table)
+                .values(data)
+                .returning());
+            if (rows.length === 0)
+                return this.error("UNPROCESSABLE_CONTENT");
+            return (0, neverthrow_1.ok)(rows[0]);
+        });
+    }
+    async createMany(data, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            if (data.length === 0) {
+                return (0, neverthrow_1.ok)([]);
+            }
+            const rows = (await db
+                .insert(this.table)
+                .values(data)
+                .returning());
+            return (0, neverthrow_1.ok)(rows);
+        });
+    }
+    async update(data, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            const single = data;
+            const id = String(single[this.idKey]);
+            const { [this.idKey]: _removed, ...rest } = single;
+            const update = rest;
+            if (this.table.updatedAt)
+                update.updatedAt = new Date();
+            const rows = (await db
+                .update(this.table)
+                .set(update)
+                .where((0, drizzle_orm_1.eq)(this.idColumn, id))
+                .returning());
+            const [row] = rows;
+            if (!row)
+                return this.error("NOT_FOUND");
+            return (0, neverthrow_1.ok)(row);
+        });
+    }
+    async updateMany(data, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            if (data.length === 0) {
+                return (0, neverthrow_1.ok)([]);
+            }
+            const results = [];
+            for (const item of data) {
+                const record = item;
+                const id = String(record[this.idKey]);
+                const { [this.idKey]: _removed, ...rest } = record;
+                const update = rest;
+                if (this.table.updatedAt)
+                    update.updatedAt = new Date();
+                const rows = (await db
+                    .update(this.table)
+                    .set(update)
+                    .where((0, drizzle_orm_1.eq)(this.idColumn, id))
+                    .returning());
+                if (rows[0])
+                    results.push(rows[0]);
+            }
+            return (0, neverthrow_1.ok)(results);
+        });
+    }
+    async softDeleteById(id, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            if (!this.table.deletedAt)
+                return this.error("METHOD_NOT_SUPPORTED");
+            const rows = await db
+                .update(this.table)
+                .set({ deletedAt: new Date() })
+                .where((0, drizzle_orm_1.eq)(this.idColumn, id))
+                .returning({
+                id: this.idColumn,
+            });
+            if (rows.length === 0)
+                return this.error("NOT_FOUND");
+            return (0, neverthrow_1.ok)(rows[0]);
+        });
+    }
+    async softDeleteManyById(ids, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            if (!this.table.deletedAt)
+                return this.error("METHOD_NOT_SUPPORTED");
+            const rows = await db
+                .update(this.table)
+                .set({ deletedAt: new Date() })
+                .where((0, drizzle_orm_1.inArray)(this.idColumn, ids))
+                .returning({
+                id: this.idColumn,
+            });
+            if (rows.length === 0)
+                return this.error("NOT_FOUND");
+            return (0, neverthrow_1.ok)(rows);
+        });
+    }
+    async deleteById(id, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            const rows = await db
+                .delete(this.table)
+                .where((0, drizzle_orm_1.eq)(this.idColumn, id))
+                .returning({
+                id: this.idColumn,
+            });
+            if (rows.length === 0)
+                return this.error("NOT_FOUND");
+            return (0, neverthrow_1.ok)(rows[0]);
+        });
+    }
+    async deleteManyById(ids, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            if (ids.length === 0) {
+                return (0, neverthrow_1.ok)([]);
+            }
+            const rows = await db
+                .delete(this.table)
+                .where((0, drizzle_orm_1.inArray)(this.idColumn, ids))
+                .returning({
+                id: this.idColumn,
+            });
+            return (0, neverthrow_1.ok)(rows);
+        });
+    }
+}
+exports.BaseTableRepository = BaseTableRepository;
+class BaseExternaRepository extends base_abstract_1.Base {
+    constructor() {
+        super("repository");
+    }
+}
+exports.BaseExternaRepository = BaseExternaRepository;

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

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePermissionService = exports.BaseService = void 0;
+const neverthrow_1 = require("neverthrow");
+const base_abstract_1 = require("#modules/base/base.abstract");
+const base_grants_1 = require("#modules/base/base.grants");
+class BaseService extends base_abstract_1.Base {
+    repository;
+    service;
+    constructor(repository = {}, service = {}) {
+        super("service");
+        this.repository = repository;
+        this.service = service;
+        this.repository = repository;
+        this.service = service;
+    }
+    addUserFilter(value, query, columnId = "userId", method = "equals") {
+        const userFilter = {
+            columnId,
+            type: "string",
+            method,
+            value,
+        };
+        return query
+            ? { ...query, filters: [...(query?.filters ?? []), userFilter] }
+            : { filters: [userFilter] };
+    }
+    addContextFilter(ctx, include = {
+        user: true,
+        organization: false,
+        team: false,
+    }, query, map = {
+        userId: {
+            columnId: "userId",
+            method: "equals",
+        },
+        organizationId: {
+            columnId: "organizationId",
+            method: "equals",
+        },
+        teamId: {
+            columnId: "teamId",
+            method: "equals",
+        },
+    }) {
+        const filters = [];
+        if (include.user) {
+            filters.push({
+                columnId: map.userId.columnId,
+                type: "string",
+                method: map.userId.method,
+                value: ctx.user.id,
+            });
+        }
+        if (include.organization) {
+            filters.push({
+                columnId: map.organizationId.columnId,
+                type: "string",
+                method: map.organizationId.method,
+                value: ctx.session.activeOrganizationId ?? "",
+            });
+        }
+        if (include.team) {
+            filters.push({
+                columnId: map.teamId.columnId,
+                type: "string",
+                method: map.teamId.method,
+                value: ctx.session.activeTeamId ?? "",
+            });
+        }
+        return query ? { ...query, filters: [...(query?.filters ?? []), ...filters] } : { filters };
+    }
+}
+exports.BaseService = BaseService;
+class BasePermissionService extends BaseService {
+    grants;
+    constructor(repository, service, grants = []) {
+        super(repository, service);
+        this.grants = grants;
+    }
+    accessGuard(ctx, action, entities, grants) {
+        const hasPermission = this.checkPermission(ctx, action, entities, grants);
+        if (!hasPermission)
+            return this.error("FORBIDDEN");
+        return (0, neverthrow_1.ok)(true);
+    }
+    async accessGuardAsync(ctx, action, getEntities, grants) {
+        const hasPermission = await this.checkPermissionAsync(ctx, action, getEntities, grants);
+        if (hasPermission.isErr())
+            return (0, neverthrow_1.err)(hasPermission.error);
+        if (!hasPermission.value)
+            return this.error("FORBIDDEN");
+        return (0, neverthrow_1.ok)(true);
+    }
+    checkPermission(ctx, action, entities, grants) {
+        const actionGrants = grants ?? this.grants.filter((grant) => grant.action === action);
+        return (0, base_grants_1.checkPermissionSync)(ctx, actionGrants, entities);
+    }
+    async checkPermissionAsync(ctx, action, getEntities, grants) {
+        const actionGrants = grants ?? this.grants.filter((grant) => grant.action === action);
+        const permission = await (0, base_grants_1.checkPermissionAsync)(ctx, actionGrants, getEntities);
+        if (permission.isErr())
+            return this.error("INTERNAL_SERVER_ERROR", "Failed to check permission", {
+                cause: permission.error,
+            });
+        return (0, neverthrow_1.ok)(permission.value);
+    }
+}
+exports.BasePermissionService = BasePermissionService;

package/dist/src/modules/base/base.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscriptions = void 0;
+const sqlite_core_1 = require("drizzle-orm/sqlite-core");
+const uuid_1 = require("uuid");
+exports.subscriptions = (0, sqlite_core_1.sqliteTable)("subscriptions", {
+    id: (0, sqlite_core_1.text)("id").primaryKey().$default(uuid_1.v4),
+    createdAt: (0, sqlite_core_1.integer)("created_at", { mode: "timestamp" })
+        .notNull()
+        .$default(() => new Date()),
+    updatedAt: (0, sqlite_core_1.integer)("updated_at", { mode: "timestamp" }),
+    plan: (0, sqlite_core_1.text)("plan").notNull(),
+    referenceId: (0, sqlite_core_1.text)("reference_id").notNull(),
+    stripeCustomerId: (0, sqlite_core_1.text)("stripe_customer_id"),
+    stripeSubscriptionId: (0, sqlite_core_1.text)("stripe_subscription_id"),
+    status: (0, sqlite_core_1.text)("status").notNull(),
+    periodStart: (0, sqlite_core_1.integer)("period_start", { mode: "timestamp" }),
+    periodEnd: (0, sqlite_core_1.integer)("period_end", { mode: "timestamp" }),
+    priceId: (0, sqlite_core_1.text)("price_id"),
+    interval: (0, sqlite_core_1.text)("interval"),
+    unitAmount: (0, sqlite_core_1.integer)("unit_amount", { mode: "number" }),
+    discounts: (0, sqlite_core_1.text)("discounts", { mode: "json" }).$type(),
+    cancelAtPeriodEnd: (0, sqlite_core_1.integer)("cancel_at_period_end", { mode: "boolean" }),
+    cancelAt: (0, sqlite_core_1.integer)("cancel_at", { mode: "timestamp" }),
+    canceledAt: (0, sqlite_core_1.integer)("canceled_at", { mode: "timestamp" }),
+    seats: (0, sqlite_core_1.integer)("seats", { mode: "number" }),
+    trialStart: (0, sqlite_core_1.integer)("trial_start", { mode: "timestamp" }),
+    trialEnd: (0, sqlite_core_1.integer)("trial_end", { mode: "timestamp" }),
+});

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;