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

package/dist/chunk-EDKWCMA7.js

@@ -0,0 +1,210 @@
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/workflows/create-merchant-charge-and-purchase.ts
+import { and, eq, inArray } from "drizzle-orm";
+import { v4 } from "uuid";
+import { parseAndExpandPurchaseBenefitTransport, PURCHASE_BENEFIT_METADATA_KEY } from "@coursebuilder/commerce/purchase-benefit-transport";
+import { couponSchema, merchantChargeSchema, merchantCouponSchema, purchaseSchema } from "@coursebuilder/core/schemas";
+import { logger as baseLogger } from "@coursebuilder/utils/logger";
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+__name(toError, "toError");
+var logger = baseLogger;
+function mergePurchaseBenefitFields(fields, expansion) {
+  if (!expansion)
+    return fields;
+  return {
+    ...fields,
+    ...expansion.success ? {
+      purchaseBenefits: expansion.benefits
+    } : {
+      purchaseBenefitsReview: expansion.review
+    }
+  };
+}
+__name(mergePurchaseBenefitFields, "mergePurchaseBenefitFields");
+function createMerchantChargeAndPurchaseWorkflow({ client, tables }) {
+  const { purchases: purchaseTable, purchaseUserTransfer, coupon, merchantCoupon, merchantCharge, merchantSession } = tables;
+  return {
+    async createMerchantChargeAndPurchase(options) {
+      const purchaseId = await client.transaction(async (trx) => {
+        try {
+          const { userId, stripeChargeId, stripeCouponId, merchantAccountId, merchantProductId, merchantCustomerId, productId, stripeChargeAmount, quantity = 1, checkoutSessionId, appliedPPPStripeCouponId, upgradedFromPurchaseId, country, usedCouponId, organizationId, attributionSnapshot } = options;
+          const existingMerchantCharge = merchantChargeSchema.nullable().parse(await trx.query.merchantCharge.findFirst({
+            where: eq(merchantCharge.identifier, stripeChargeId)
+          }) || null);
+          const existingPurchaseForCharge = existingMerchantCharge ? await trx.query.purchases.findFirst({
+            where: eq(purchaseTable.merchantChargeId, existingMerchantCharge.id),
+            with: {
+              user: true,
+              product: true,
+              bulkCoupon: true
+            }
+          }) : null;
+          if (existingPurchaseForCharge) {
+            return existingPurchaseForCharge.id;
+          }
+          const merchantChargeId = `mc_${v4()}`;
+          const purchaseId2 = `purch_${v4()}`;
+          const newMerchantCharge = await trx.insert(merchantCharge).values({
+            id: merchantChargeId,
+            userId,
+            identifier: stripeChargeId,
+            merchantAccountId,
+            merchantProductId,
+            merchantCustomerId
+          });
+          const existingPurchase = purchaseSchema.nullable().parse(await trx.query.purchases.findFirst({
+            where: and(eq(purchaseTable.productId, productId), eq(purchaseTable.userId, userId), inArray(purchaseTable.status, [
+              "Valid",
+              "Restricted"
+            ]))
+          }) || null);
+          const existingBulkCoupon = couponSchema.nullable().parse(await trx.select().from(coupon).leftJoin(purchaseTable, and(eq(coupon.id, purchaseTable.bulkCouponId), eq(purchaseTable.userId, userId))).where(and(eq(coupon.restrictedToProductId, productId), eq(purchaseTable.userId, userId), eq(purchaseTable.status, "Valid"))).then((res) => {
+            return res[0]?.Coupon ?? null;
+          }));
+          const isBulkPurchase = quantity > 1 || Boolean(existingBulkCoupon) || Boolean(options.bulk);
+          let bulkCouponId = null;
+          let couponToUpdate = null;
+          const purchaseBenefitsTransport = options.purchaseBenefitsTransport?.trim() || void 0;
+          const purchaseBenefitExpansion = purchaseBenefitsTransport ? parseAndExpandPurchaseBenefitTransport({
+            transport: purchaseBenefitsTransport,
+            appliesTo: isBulkPurchase ? "redeemed_team_seat" : "buyer"
+          }) : null;
+          if (purchaseBenefitExpansion && !purchaseBenefitExpansion.success) {
+            logger.info("purchase_benefits.transport.needs_review", {
+              checkoutSessionId,
+              event: "purchase_benefits.transport.needs_review",
+              metadataKey: PURCHASE_BENEFIT_METADATA_KEY,
+              productId,
+              stripeChargeId,
+              userId,
+              errors: purchaseBenefitExpansion.review.errors
+            });
+          }
+          if (isBulkPurchase) {
+            bulkCouponId = existingBulkCoupon !== null ? existingBulkCoupon.id : v4();
+            if (existingBulkCoupon !== null) {
+              const existingCouponFields = existingBulkCoupon.fields ?? {};
+              couponToUpdate = await trx.update(coupon).set({
+                maxUses: (existingBulkCoupon?.maxUses || 0) + quantity,
+                fields: mergePurchaseBenefitFields(existingCouponFields, purchaseBenefitExpansion),
+                ...organizationId ? {
+                  organizationId
+                } : {}
+              }).where(eq(coupon.id, bulkCouponId));
+            } else {
+              let merchantCouponToUse = stripeCouponId ? merchantCouponSchema.nullable().parse(await trx.query.merchantCoupon.findFirst({
+                where: eq(merchantCoupon.identifier, stripeCouponId)
+              }) || null) : null;
+              if (!merchantCouponToUse && usedCouponId) {
+                const usedCoupon = couponSchema.nullable().parse(await trx.query.coupon.findFirst({
+                  where: eq(coupon.id, usedCouponId)
+                }) || null);
+                if (usedCoupon?.merchantCouponId) {
+                  merchantCouponToUse = merchantCouponSchema.nullable().parse(await trx.query.merchantCoupon.findFirst({
+                    where: eq(merchantCoupon.id, usedCoupon.merchantCouponId)
+                  }) || null);
+                }
+              }
+              const bulkCouponValues = {
+                id: bulkCouponId,
+                percentageDiscount: "1.0",
+                restrictedToProductId: productId,
+                maxUses: quantity,
+                status: 1,
+                fields: mergePurchaseBenefitFields({}, purchaseBenefitExpansion),
+                ...organizationId ? {
+                  organizationId
+                } : {},
+                ...merchantCouponToUse ? {
+                  merchantCouponId: merchantCouponToUse.id
+                } : {}
+              };
+              couponToUpdate = await trx.insert(coupon).values(bulkCouponValues);
+            }
+          }
+          const merchantSessionId = `ms_${v4()}`;
+          await trx.insert(merchantSession).values({
+            id: merchantSessionId,
+            identifier: checkoutSessionId,
+            merchantAccountId
+          });
+          const merchantCouponUsed = stripeCouponId ? await trx.query.merchantCoupon.findFirst({
+            where: eq(merchantCoupon.identifier, stripeCouponId)
+          }) : null;
+          const pppMerchantCoupon = appliedPPPStripeCouponId ? await trx.query.merchantCoupon.findFirst({
+            where: and(eq(merchantCoupon.identifier, appliedPPPStripeCouponId), eq(merchantCoupon.type, "ppp"))
+          }) : null;
+          const newPurchaseStatus = merchantCouponUsed?.type === "ppp" || pppMerchantCoupon ? "Restricted" : "Valid";
+          await trx.insert(purchaseTable).values({
+            id: purchaseId2,
+            status: newPurchaseStatus,
+            userId,
+            productId,
+            merchantChargeId,
+            totalAmount: (stripeChargeAmount / 100).toFixed(),
+            bulkCouponId,
+            merchantSessionId,
+            country,
+            fields: {
+              ...!isBulkPurchase ? mergePurchaseBenefitFields({}, purchaseBenefitExpansion) : {},
+              ...attributionSnapshot ? {
+                attribution: attributionSnapshot
+              } : {}
+            },
+            upgradedFromId: upgradedFromPurchaseId || null,
+            couponId: usedCouponId || null,
+            ...organizationId ? {
+              organizationId
+            } : {}
+          });
+          const oneWeekInMilliseconds = 1e3 * 60 * 60 * 24 * 7;
+          await trx.insert(purchaseUserTransfer).values({
+            id: `put_${v4()}`,
+            purchaseId: purchaseId2,
+            expiresAt: existingPurchase ? /* @__PURE__ */ new Date() : new Date(Date.now() + oneWeekInMilliseconds),
+            sourceUserId: userId,
+            ...organizationId ? {
+              organizationId
+            } : {}
+          });
+          return purchaseId2;
+        } catch (error) {
+          logger.error(toError(error), {
+            checkoutSessionId: options.checkoutSessionId,
+            event: "adapter.purchase.create.failed",
+            organizationId: options.organizationId,
+            productId: options.productId,
+            stripeChargeId: options.stripeChargeId,
+            userId: options.userId
+          });
+          trx.rollback();
+          throw error;
+        }
+      });
+      const parsedPurchase = purchaseSchema.safeParse(await client.query.purchases.findFirst({
+        where: eq(purchaseTable.id, purchaseId)
+      }));
+      if (!parsedPurchase.success) {
+        logger.error(parsedPurchase.error, {
+          event: "adapter.purchase.parse_failed",
+          productId: options.productId,
+          purchaseId,
+          userId: options.userId
+        });
+        throw new Error("Error parsing purchase");
+      }
+      return parsedPurchase.data;
+    }
+  };
+}
+__name(createMerchantChargeAndPurchaseWorkflow, "createMerchantChargeAndPurchaseWorkflow");
+
+export {
+  createMerchantChargeAndPurchaseWorkflow
+};
+//# sourceMappingURL=chunk-EDKWCMA7.js.map

package/dist/{chunk-CFSRMUNC.js → chunk-EDM6DKA5.js}

@@ -1,6 +1,6 @@
 import {
   getRolesSchema
-} from "./chunk-W6RPAAKG.js";
+} from "./chunk-XUBZKYH6.js";
 import {
   getPermissionsSchema
 } from "./chunk-UWUDJCJM.js";
@@ -75,4 +75,4 @@ export {
   getRolePermissionsSchema,
   getRolePermissionsRelationsSchema
 };
-//# sourceMappingURL=chunk-CFSRMUNC.js.map
+//# sourceMappingURL=chunk-EDM6DKA5.js.map

package/dist/{chunk-EZEQQJNH.js → chunk-EIQBTF5J.js}

@@ -1,6 +1,6 @@
 import {
   getProductSchema
-} from "./chunk-PNPTKVJ4.js";
+} from "./chunk-XUBZKYH6.js";
 import {
   __name
 } from "./chunk-2X5XVNDN.js";
@@ -76,4 +76,4 @@ export {
   getUpgradableProductsSchema,
   getUpgradableProductsRelationsSchema
 };
-//# sourceMappingURL=chunk-EZEQQJNH.js.map
+//# sourceMappingURL=chunk-EIQBTF5J.js.map

package/dist/chunk-FYT7RTVW.js

@@ -0,0 +1,248 @@
+import {
+  guid,
+  normalizeExpirationDate
+} from "./chunk-6XQ6C3IX.js";
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/workflows/create-workshop.ts
+import slugify from "@sindresorhus/slugify";
+import { asc, eq } from "drizzle-orm";
+import { ContentResourceSchema } from "@coursebuilder/core/schemas/content-resource-schema";
+import { logger as baseLogger } from "@coursebuilder/utils/logger";
+var logger = baseLogger;
+function createWorkshopWorkflow({ client, tables }, operations) {
+  const { contentResource, contentResourceResource, contentResourceProduct, contentResourceTag } = tables;
+  return {
+    async createWorkshop(input, userId) {
+      const hash = guid();
+      const workshopId = `workshop~${hash}`;
+      const result = await client.transaction(async (tx) => {
+        await tx.insert(contentResource).values({
+          id: workshopId,
+          type: "workshop",
+          createdById: userId,
+          fields: {
+            title: input.workshop.title,
+            description: input.workshop.description,
+            state: "draft",
+            visibility: "unlisted",
+            slug: slugify(`${input.workshop.title}~${hash}`)
+          }
+        });
+        const workshop = await tx.query.contentResource.findFirst({
+          where: eq(contentResource.id, workshopId),
+          with: {
+            resources: {
+              with: {
+                resource: {
+                  with: {
+                    resources: {
+                      with: {
+                        resource: true
+                      },
+                      orderBy: asc(contentResourceResource.position)
+                    }
+                  }
+                }
+              },
+              orderBy: asc(contentResourceResource.position)
+            }
+          }
+        });
+        if (!workshop) {
+          throw new Error("Failed to create workshop");
+        }
+        const parsedWorkshop = ContentResourceSchema.safeParse(workshop);
+        if (!parsedWorkshop.success) {
+          throw new Error("Invalid workshop data");
+        }
+        if (input.workshop.tagIds) {
+          await tx.insert(contentResourceTag).values(input.workshop.tagIds.map((tag) => ({
+            contentResourceId: workshopId,
+            tagId: tag.id,
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date(),
+            position: 0
+          })));
+        }
+        const createdSections = [];
+        const createdLessons = [];
+        let position = 0;
+        for (const item of input.structure) {
+          if (item.type === "section") {
+            const sectionHash = guid();
+            const sectionId = `section~${sectionHash}`;
+            await tx.insert(contentResource).values({
+              id: sectionId,
+              type: "section",
+              createdById: userId,
+              fields: {
+                title: item.title,
+                state: "draft",
+                visibility: "unlisted",
+                slug: slugify(`${item.title}~${sectionHash}`)
+              }
+            });
+            await tx.insert(contentResourceResource).values({
+              resourceOfId: workshopId,
+              resourceId: sectionId,
+              position
+            });
+            const section = await tx.query.contentResource.findFirst({
+              where: eq(contentResource.id, sectionId)
+            });
+            if (section) {
+              createdSections.push(section);
+            }
+            let lessonPosition = 0;
+            for (const lessonData of item.lessons) {
+              const lessonHash = guid();
+              const lessonId = `lesson_${lessonHash}`;
+              await tx.insert(contentResource).values({
+                id: lessonId,
+                type: "lesson",
+                createdById: userId,
+                fields: {
+                  title: lessonData.title,
+                  state: "draft",
+                  visibility: "unlisted",
+                  slug: slugify(`${lessonData.title}~${lessonHash}`),
+                  lessonType: "lesson"
+                }
+              });
+              if (lessonData.videoResourceId) {
+                await tx.insert(contentResourceResource).values({
+                  resourceOfId: lessonId,
+                  resourceId: lessonData.videoResourceId,
+                  position: 0
+                });
+              }
+              await tx.insert(contentResourceResource).values({
+                resourceOfId: sectionId,
+                resourceId: lessonId,
+                position: lessonPosition
+              });
+              const lesson = await tx.query.contentResource.findFirst({
+                where: eq(contentResource.id, lessonId)
+              });
+              if (lesson) {
+                createdLessons.push(lesson);
+              }
+              lessonPosition++;
+            }
+            position++;
+          } else {
+            const lessonHash = guid();
+            const lessonId = `lesson_${lessonHash}`;
+            await tx.insert(contentResource).values({
+              id: lessonId,
+              type: "lesson",
+              createdById: userId,
+              fields: {
+                title: item.title,
+                state: "draft",
+                visibility: "unlisted",
+                slug: slugify(`${item.title}~${lessonHash}`),
+                lessonType: "lesson"
+              }
+            });
+            if (item.videoResourceId) {
+              await tx.insert(contentResourceResource).values({
+                resourceOfId: lessonId,
+                resourceId: item.videoResourceId,
+                position: 0
+              });
+            }
+            await tx.insert(contentResourceResource).values({
+              resourceOfId: workshopId,
+              resourceId: lessonId,
+              position
+            });
+            const lesson = await tx.query.contentResource.findFirst({
+              where: eq(contentResource.id, lessonId)
+            });
+            if (lesson) {
+              createdLessons.push(lesson);
+            }
+            position++;
+          }
+        }
+        return {
+          workshop: parsedWorkshop.data,
+          sections: createdSections,
+          lessons: createdLessons
+        };
+      });
+      let product = null;
+      if (input.createProduct && input.pricing.price && input.pricing.price > 0) {
+        try {
+          product = await operations.createProduct({
+            name: input.workshop.title,
+            price: input.pricing.price,
+            quantityAvailable: input.pricing.quantity ?? -1,
+            type: "self-paced",
+            state: "published",
+            visibility: "public"
+          });
+          if (product) {
+            await client.insert(contentResourceProduct).values({
+              resourceId: workshopId,
+              productId: product.id,
+              position: 0,
+              metadata: {
+                addedBy: userId
+              }
+            });
+            if (input.coupon?.enabled && input.coupon.percentageDiscount && input.coupon.expires) {
+              try {
+                const finalExpires = normalizeExpirationDate(input.coupon.expires);
+                await operations.createCoupon({
+                  percentageDiscount: input.coupon.percentageDiscount,
+                  expires: finalExpires || null,
+                  restrictedToProductId: product.id,
+                  default: true,
+                  maxUses: -1,
+                  quantity: "-1",
+                  status: 1,
+                  fields: {}
+                });
+                logger.debug("workshop.create.coupon.success", {
+                  workshopId,
+                  productId: product.id,
+                  userId,
+                  percentageDiscount: input.coupon.percentageDiscount
+                });
+              } catch (couponError) {
+                logger.error(new Error(`Failed to create coupon for workshop: ${couponError}`));
+                logger.debug("workshop.create.coupon.failed", {
+                  workshopId,
+                  productId: product.id,
+                  userId
+                });
+              }
+            }
+          }
+        } catch (productError) {
+          logger.error(new Error(`Failed to create product for workshop: ${productError}`));
+          logger.debug("workshop.create.product.failed", {
+            workshopId,
+            userId,
+            price: input.pricing.price
+          });
+        }
+      }
+      return {
+        ...result,
+        product
+      };
+    }
+  };
+}
+__name(createWorkshopWorkflow, "createWorkshopWorkflow");
+
+export {
+  createWorkshopWorkflow
+};
+//# sourceMappingURL=chunk-FYT7RTVW.js.map

package/dist/{chunk-DUFH5L2F.js → chunk-INZTF6QV.js}

@@ -1,6 +1,6 @@
 import {
   getUsersSchema
-} from "./chunk-W6RPAAKG.js";
+} from "./chunk-XUBZKYH6.js";
 import {
   __name
 } from "./chunk-2X5XVNDN.js";
@@ -46,4 +46,4 @@ export {
   getSessionsSchema,
   getSessionRelationsSchema
 };
-//# sourceMappingURL=chunk-DUFH5L2F.js.map
+//# sourceMappingURL=chunk-INZTF6QV.js.map

package/dist/{chunk-3AF6MZQ7.js → chunk-JVHX4JHA.js}

@@ -1,7 +1,7 @@
 import {
   getPurchaseSchema,
   getUsersSchema
-} from "./chunk-W6RPAAKG.js";
+} from "./chunk-XUBZKYH6.js";
 import {
   __name
 } from "./chunk-2X5XVNDN.js";
@@ -109,4 +109,4 @@ export {
   getPurchaseUserTransferSchema,
   getPurchaseUserTransferRelationsSchema
 };
-//# sourceMappingURL=chunk-3AF6MZQ7.js.map
+//# sourceMappingURL=chunk-JVHX4JHA.js.map