@coursebuilder/adapter-drizzle 2.1.0 → 3.0.0-canary.0.0c9beb2ae

package/dist/chunk-QO3QE3LE.js

@@ -0,0 +1,330 @@
+import {
+  external_exports
+} from "./chunk-QKOSV34V.js";
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/ports/purchase.ts
+import { and, asc, eq, inArray, isNull, not, or } from "drizzle-orm";
+import { v4 } from "uuid";
+import { merchantChargeSchema, purchaseSchema, purchaseUserTransferSchema, upgradableProductSchema, userSchema } from "@coursebuilder/core/schemas";
+import { logger as baseLogger } from "@coursebuilder/utils/logger";
+var logger = baseLogger;
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+__name(toError, "toError");
+function createPurchasePort({ client, tables }) {
+  const { purchases: purchaseTable, purchaseUserTransfer, merchantCharge, merchantCustomer, merchantSession, upgradableProducts } = tables;
+  const purchasePort = {
+    createPurchaseTransfer: async (options) => {
+      const id = `put_${v4()}`;
+      await client.insert(purchaseUserTransfer).values({
+        id,
+        purchaseId: options.purchaseId,
+        sourceUserId: options.sourceUserId,
+        expiresAt: options.expiresAt
+      });
+    },
+    getExistingNonBulkValidPurchasesOfProduct: async ({ userId, productId }) => {
+      const existingPurchases = await client.query.purchases.findMany({
+        where: and(eq(purchaseTable.userId, userId), productId ? eq(purchaseTable.productId, productId) : void 0, eq(purchaseTable.status, "Valid"), isNull(purchaseTable.bulkCouponId))
+      });
+      return external_exports.array(purchaseSchema).parse(existingPurchases);
+    },
+    async getPurchasesForBulkCouponId(bulkCouponId) {
+      return external_exports.array(purchaseSchema.extend({
+        user: userSchema
+      })).parse(await client.query.purchases.findMany({
+        where: eq(purchaseTable.bulkCouponId, bulkCouponId),
+        with: {
+          user: true
+        }
+      }));
+    },
+    async getPurchaseCountForProduct(productId) {
+      return await client.query.purchases.findMany({
+        where: and(eq(purchaseTable.productId, productId), inArray(purchaseTable.status, [
+          "Valid",
+          "Restricted"
+        ]))
+      }).then((res) => res.length);
+    },
+    async getPurchase(purchaseId) {
+      const purchase = await client.query.purchases.findFirst({
+        where: eq(purchaseTable.id, purchaseId)
+      });
+      return purchase ? purchaseSchema.parse(purchase) : null;
+    },
+    async createPurchase(options) {
+      const newPurchaseId = options.id || `purchase-${v4()}`;
+      await client.insert(purchaseTable).values({
+        ...options,
+        id: newPurchaseId
+      });
+      const newPurchase = await purchasePort.getPurchase(newPurchaseId);
+      return purchaseSchema.parse(newPurchase);
+    },
+    async getPurchaseForStripeCharge(stripeChargeId) {
+      logger.debug("getPurchaseForStripeCharge", {
+        stripeChargeId
+      });
+      const chargeForPurchase = merchantChargeSchema.nullable().parse(await client.query.merchantCharge.findFirst({
+        where: eq(merchantCharge.identifier, stripeChargeId)
+      }) || null);
+      if (!chargeForPurchase) {
+        logger.debug("getPurchaseForStripeCharge: no matching charge", {
+          stripeChargeId,
+          idPrefix: stripeChargeId?.substring(0, 3)
+        });
+        return null;
+      }
+      const purchase = purchaseSchema.safeParse(await client.query.purchases.findFirst({
+        where: eq(purchaseTable.merchantChargeId, chargeForPurchase.id),
+        with: {
+          user: true,
+          product: true,
+          bulkCoupon: true
+        }
+      }));
+      if (!purchase.success) {
+        return null;
+      }
+      return purchase.data;
+    },
+    async getPurchaseByCheckoutSessionId(checkoutSessionId) {
+      logger.debug("getPurchaseByCheckoutSessionId", {
+        checkoutSessionId
+      });
+      const session = await client.query.merchantSession.findFirst({
+        where: eq(merchantSession.identifier, checkoutSessionId)
+      });
+      if (!session) {
+        logger.debug("getPurchaseByCheckoutSessionId: no matching session", {
+          checkoutSessionId
+        });
+        return null;
+      }
+      const purchase = purchaseSchema.safeParse(await client.query.purchases.findFirst({
+        where: eq(purchaseTable.merchantSessionId, String(session.id)),
+        with: {
+          user: true,
+          product: true,
+          bulkCoupon: true
+        }
+      }));
+      if (!purchase.success) {
+        return null;
+      }
+      return purchase.data;
+    },
+    async getPurchaseUserTransferById(options) {
+      const purchaseTransferData = await client.query.purchaseUserTransfer.findFirst({
+        where: eq(purchaseUserTransfer.id, options.id),
+        with: {
+          sourceUser: true,
+          targetUser: true,
+          purchase: true
+        }
+      });
+      return purchaseUserTransferSchema.merge(external_exports.object({
+        sourceUser: userSchema,
+        targetUser: userSchema.nullable(),
+        purchase: purchaseSchema,
+        organizationId: external_exports.string().nullable()
+      })).nullable().parse(purchaseTransferData);
+    },
+    async getPurchaseWithUser(purchaseId) {
+      const purchaseData = await client.query.purchases.findFirst({
+        where: eq(purchaseTable.id, purchaseId),
+        with: {
+          user: true
+        }
+      }) || null;
+      const parsedPurchase = purchaseSchema.merge(external_exports.object({
+        user: userSchema
+      })).nullable().safeParse(purchaseData);
+      if (!parsedPurchase.success) {
+        logger.error(parsedPurchase.error, {
+          event: "adapter.purchase.parse_failed",
+          purchaseId
+        });
+        return null;
+      }
+      return parsedPurchase.data;
+    },
+    async getPurchasesForUser(userId) {
+      if (!userId) {
+        return [];
+      }
+      const visiblePurchaseStates = [
+        "Valid",
+        "Refunded",
+        "Restricted"
+      ];
+      const userPurchases = await client.query.purchases.findMany({
+        where: and(eq(purchaseTable.userId, userId), inArray(purchaseTable.status, visiblePurchaseStates)),
+        with: {
+          user: true,
+          product: true,
+          bulkCoupon: true
+        },
+        orderBy: asc(purchaseTable.createdAt)
+      });
+      const parsedPurchases = external_exports.array(purchaseSchema).safeParse(userPurchases);
+      if (!parsedPurchases.success) {
+        logger.error(parsedPurchases.error, {
+          event: "adapter.purchase.list.parse_failed",
+          purchaseCount: userPurchases.length,
+          userId
+        });
+        return [];
+      }
+      return parsedPurchases.data;
+    },
+    async getPurchaseDetails(purchaseId, userId) {
+      const visiblePurchaseStates = [
+        "Valid",
+        "Refunded",
+        "Restricted"
+      ];
+      const userPurchases = await client.query.purchases.findMany({
+        where: and(eq(purchaseTable.userId, userId), inArray(purchaseTable.status, visiblePurchaseStates)),
+        with: {
+          user: true,
+          product: true,
+          bulkCoupon: true
+        },
+        orderBy: asc(purchaseTable.createdAt)
+      });
+      const parsedPurchases = external_exports.array(purchaseSchema).safeParse(userPurchases);
+      const allPurchases = parsedPurchases.success ? parsedPurchases.data : [];
+      const thePurchase = await client.query.purchases.findFirst({
+        where: and(eq(purchaseTable.id, purchaseId), eq(purchaseTable.userId, userId)),
+        with: {
+          user: true,
+          product: true,
+          bulkCoupon: true
+        }
+      });
+      const parsedPurchase = purchaseSchema.safeParse(thePurchase);
+      if (!parsedPurchase.success) {
+        logger.error(parsedPurchase.error, {
+          event: "adapter.purchase.details.parse_failed",
+          purchaseId,
+          userId
+        });
+        return {
+          availableUpgrades: []
+        };
+      }
+      const purchaseCanUpgrade = [
+        "Valid",
+        "Restricted"
+      ].includes(parsedPurchase.data.state || "");
+      let availableUpgrades = [];
+      if (purchaseCanUpgrade) {
+        availableUpgrades = await client.query.upgradableProducts.findMany({
+          where: and(eq(upgradableProducts.upgradableFromId, parsedPurchase.data.product?.id), not(inArray(upgradableProducts.upgradableToId, allPurchases.map((p) => p.product?.id)))),
+          with: {
+            upgradableTo: true,
+            upgradableFrom: true
+          }
+        });
+      }
+      const existingPurchase = purchaseSchema.optional().nullable().parse(await client.query.purchases.findFirst({
+        where: and(eq(purchaseTable.userId, userId), eq(purchaseTable.productId, parsedPurchase.data.productId), inArray(purchaseTable.status, [
+          "Valid",
+          "Restricted"
+        ]), isNull(purchaseTable.bulkCouponId), not(eq(purchaseTable.id, parsedPurchase.data.id))),
+        with: {
+          user: true,
+          product: true,
+          bulkCoupon: true
+        }
+      }) || null);
+      return {
+        availableUpgrades: external_exports.array(upgradableProductSchema).parse(availableUpgrades),
+        existingPurchase,
+        purchase: parsedPurchase.data
+      };
+    },
+    async transferPurchasesToNewUser(options) {
+      await client.transaction(async (trx) => {
+        const charges = await trx.select({
+          id: merchantCharge.id
+        }).from(merchantCharge).where(eq(merchantCharge.merchantCustomerId, options.merchantCustomerId));
+        const chargeIds = charges.map(({ id }) => id);
+        if (chargeIds.length > 0) {
+          await trx.update(purchaseTable).set({
+            userId: options.userId
+          }).where(inArray(purchaseTable.merchantChargeId, chargeIds));
+          await trx.update(merchantCharge).set({
+            userId: options.userId
+          }).where(inArray(merchantCharge.id, chargeIds));
+        }
+        await trx.update(merchantCustomer).set({
+          userId: options.userId
+        }).where(eq(merchantCustomer.id, options.merchantCustomerId));
+      });
+    },
+    async updatePurchaseStatusForCharge(chargeId, status) {
+      try {
+        logger.debug("adapter.purchase.status_update.started", {
+          chargeId,
+          status
+        });
+        const merchantChargeForPurchase = await client.query.merchantCharge.findFirst({
+          where: or(eq(merchantCharge.identifier, chargeId), eq(merchantCharge.id, chargeId))
+        });
+        logger.debug("adapter.purchase.status_update.charge_resolved", {
+          chargeId,
+          merchantChargeId: merchantChargeForPurchase?.id ?? null,
+          merchantChargeIdentifier: merchantChargeForPurchase?.identifier ?? null
+        });
+        const parsedMerchantChargeForPurchase = merchantChargeSchema.parse(merchantChargeForPurchase);
+        if (!parsedMerchantChargeForPurchase)
+          throw new Error(`no-charge-found-for-purchase ${chargeId}`);
+        const purchase = await client.query.purchases.findFirst({
+          where: eq(purchaseTable.merchantChargeId, parsedMerchantChargeForPurchase.id)
+        });
+        const parsedPurchase = purchaseSchema.nullable().parse(purchase);
+        if (parsedPurchase) {
+          await client.update(purchaseTable).set({
+            status
+          }).where(eq(purchaseTable.id, parsedPurchase.id));
+          const newPurchase = await client.query.purchases.findFirst({
+            where: eq(purchaseTable.id, parsedPurchase.id)
+          });
+          return purchaseSchema.optional().parse(newPurchase);
+        } else {
+          throw new Error(`no-purchase-found-for-charge ${chargeId}`);
+        }
+      } catch (e) {
+        logger.error(toError(e), {
+          chargeId,
+          event: "adapter.purchase.status_update.failed",
+          status
+        });
+        throw e;
+      }
+    },
+    async updatePurchaseUserTransferTransferState(options) {
+      await client.update(purchaseUserTransfer).set({
+        transferState: options.transferState
+      }).where(eq(purchaseUserTransfer.id, options.id));
+      const purchaseUserTransferData = await client.query.purchaseUserTransfer.findFirst({
+        where: eq(purchaseUserTransfer.id, options.id)
+      }) || null;
+      return purchaseUserTransferSchema.nullable().parse(purchaseUserTransferData);
+    }
+  };
+  return purchasePort;
+}
+__name(createPurchasePort, "createPurchasePort");
+
+export {
+  createPurchasePort
+};
+//# sourceMappingURL=chunk-QO3QE3LE.js.map