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

package/dist/chunk-EAXC4CQD.js

@@ -0,0 +1,245 @@
+import {
+  external_exports
+} from "./chunk-QKOSV34V.js";
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/ports/coupon.ts
+import { and, desc, eq, gte, inArray, isNull, or, sql } from "drizzle-orm";
+import { customAlphabet } from "nanoid";
+import { v4 } from "uuid";
+import { couponSchema, merchantCouponSchema, purchaseSchema } from "@coursebuilder/core/schemas";
+import { logger as baseLogger } from "@coursebuilder/utils/logger";
+var guid = customAlphabet("1234567890abcdefghijklmnopqrstuvwxyz", 5);
+var logger = baseLogger;
+function createCouponPort({ client, tables }) {
+  const { coupon, merchantCoupon, purchases: purchaseTable } = tables;
+  return {
+    incrementCouponUsedCount: async (couponId) => {
+      await client.update(coupon).set({
+        usedCount: sql`${coupon.usedCount} + 1`
+      }).where(eq(coupon.id, couponId));
+    },
+    createMerchantCoupon: async (options) => {
+      await client.insert(merchantCoupon).values({
+        id: `mcoupon_${v4()}`,
+        identifier: options.identifier,
+        merchantAccountId: options.merchantAccountId,
+        type: options.type,
+        amountDiscount: Math.floor(options.amountDiscount),
+        status: 1
+      });
+      return merchantCouponSchema.parse(await client.query.merchantCoupon.findFirst({
+        where: eq(merchantCoupon.identifier, options.identifier)
+      }));
+    },
+    async couponForIdOrCode(options) {
+      if (!options.couponId && !options.code)
+        return null;
+      const couponForIdOrCode = await client.query.coupon.findFirst({
+        where: or(and(or(options.code ? eq(coupon.code, options.code) : void 0, options.couponId ? eq(coupon.id, options.couponId) : void 0), gte(coupon.expires, /* @__PURE__ */ new Date())), and(or(options.code ? eq(coupon.code, options.code) : void 0, options.couponId ? eq(coupon.id, options.couponId) : void 0), isNull(coupon.expires))),
+        with: {
+          merchantCoupon: true
+        }
+      });
+      if (!couponForIdOrCode)
+        return null;
+      const parsedCoupon = couponSchema.extend({
+        merchantCoupon: merchantCouponSchema
+      }).safeParse(couponForIdOrCode);
+      if (!parsedCoupon.success) {
+        logger.error(parsedCoupon.error, {
+          code: options.code,
+          couponId: options.couponId,
+          event: "adapter.coupon.parse_failed"
+        });
+        return null;
+      }
+      return parsedCoupon.data;
+    },
+    async getCoupon(couponIdOrCode) {
+      const loadedCoupon = await client.query.coupon.findFirst({
+        where: or(eq(coupon.id, couponIdOrCode), eq(coupon.code, couponIdOrCode))
+      }) || null;
+      logger.debug("getCoupon", {
+        couponIdOrCode,
+        found: !!loadedCoupon
+      });
+      return couponSchema.nullable().parse(loadedCoupon);
+    },
+    async getCouponWithBulkPurchases(couponId) {
+      logger.debug("getCouponWithBulkPurchases", {
+        couponId
+      });
+      let couponData;
+      let bulkCouponPurchases = [];
+      try {
+        couponData = await client.query.coupon.findFirst({
+          where: eq(coupon.id, couponId),
+          with: {
+            bulkPurchases: true,
+            redeemedBulkCouponPurchases: true
+          }
+        }) || null;
+      } catch (e) {
+        logger.error(e, {
+          method: "getCouponWithBulkPurchases",
+          couponId,
+          step: "load-coupon"
+        });
+      }
+      try {
+        bulkCouponPurchases = await client.query.purchases.findMany({
+          where: eq(purchaseTable.redeemedBulkCouponId, couponId),
+          with: {
+            user: true
+          }
+        });
+        logger.debug("getCouponWithBulkPurchases.redeemed", {
+          couponId,
+          count: bulkCouponPurchases?.length ?? 0
+        });
+      } catch (e) {
+        logger.error(e, {
+          method: "getCouponWithBulkPurchases",
+          couponId,
+          step: "load-redeemed-purchases"
+        });
+      }
+      if (!couponData) {
+        logger.debug("getCouponWithBulkPurchases", {
+          couponId,
+          error: "no coupon found"
+        });
+        return null;
+      }
+      const couponWithBulkPurchases = {
+        ...couponData,
+        redeemedBulkCouponPurchases: bulkCouponPurchases || []
+      };
+      const parsedCoupon = couponSchema.merge(external_exports.object({
+        redeemedBulkCouponPurchases: external_exports.array(purchaseSchema)
+      })).nullable().safeParse(couponWithBulkPurchases);
+      if (!parsedCoupon.success) {
+        logger.error(parsedCoupon.error, {
+          couponId: couponData?.id ?? couponId,
+          event: "adapter.coupon.parse_failed",
+          redeemedBulkCouponPurchasesCount: bulkCouponPurchases?.length ?? 0
+        });
+        return null;
+      }
+      return parsedCoupon.data;
+    },
+    async getDefaultCoupon(productIds) {
+      const activeSaleCoupon = await client.query.coupon.findFirst({
+        where: and(eq(coupon.status, 1), eq(coupon.default, true), gte(coupon.expires, /* @__PURE__ */ new Date()), or(productIds ? inArray(coupon.restrictedToProductId, productIds) : void 0, isNull(coupon.restrictedToProductId))),
+        orderBy: desc(coupon.percentageDiscount),
+        with: {
+          merchantCoupon: true,
+          product: true
+        }
+      });
+      if (activeSaleCoupon) {
+        const { restrictedToProductId } = activeSaleCoupon;
+        const validForProdcutId = restrictedToProductId ? productIds?.includes(restrictedToProductId) : true;
+        const { merchantCoupon: defaultMerchantCoupon, ...defaultCoupon } = activeSaleCoupon;
+        if (validForProdcutId) {
+          return {
+            defaultMerchantCoupon: merchantCouponSchema.parse(defaultMerchantCoupon),
+            defaultCoupon: couponSchema.parse(defaultCoupon)
+          };
+        }
+      }
+      return null;
+    },
+    async getMerchantCouponsForTypeAndPercent(params) {
+      return external_exports.array(merchantCouponSchema).parse(await client.query.merchantCoupon.findMany({
+        where: and(eq(merchantCoupon.type, params.type), eq(merchantCoupon.percentageDiscount, params.percentageDiscount.toString()))
+      }));
+    },
+    async getMerchantCouponForTypeAndPercent(params) {
+      const foundMerchantCoupon = await client.query.merchantCoupon.findFirst({
+        where: and(eq(merchantCoupon.type, params.type), eq(merchantCoupon.percentageDiscount, params.percentageDiscount.toString()))
+      });
+      const parsed = merchantCouponSchema.nullable().safeParse(foundMerchantCoupon);
+      if (parsed.success) {
+        return parsed.data;
+      }
+      return null;
+    },
+    async getMerchantCouponForTypeAndAmount(params) {
+      const foundMerchantCoupon = await client.query.merchantCoupon.findFirst({
+        where: and(eq(merchantCoupon.type, params.type), eq(merchantCoupon.amountDiscount, params.amountDiscount))
+      });
+      const parsed = merchantCouponSchema.nullable().safeParse(foundMerchantCoupon);
+      if (parsed.success) {
+        return parsed.data;
+      }
+      return null;
+    },
+    async getMerchantCoupon(merchantCouponId) {
+      const foundMerchantCoupon = await client.query.merchantCoupon.findFirst({
+        where: eq(merchantCoupon.id, merchantCouponId)
+      });
+      const parsed = merchantCouponSchema.nullable().safeParse(foundMerchantCoupon);
+      if (parsed.success) {
+        return parsed.data;
+      }
+      return null;
+    },
+    async createCoupon(input) {
+      function findClosestDiscount(percentOff) {
+        percentOff = percentOff <= 1 ? percentOff : percentOff / 100;
+        return [
+          1,
+          0.95,
+          0.9,
+          0.75,
+          0.6,
+          0.5,
+          0.4,
+          0.25,
+          0.1
+        ].reduce((a, b) => {
+          let aDiff = Math.abs(a - percentOff);
+          let bDiff = Math.abs(b - percentOff);
+          if (aDiff === bDiff) {
+            return a > b ? a : b;
+          } else {
+            return bDiff < aDiff ? b : a;
+          }
+        });
+      }
+      __name(findClosestDiscount, "findClosestDiscount");
+      const percentageDiscount = findClosestDiscount(Number(input.percentageDiscount) * 100);
+      const merchantCouponResult = percentageDiscount < 1 ? await client.query.merchantCoupon.findFirst({
+        where: and(eq(merchantCoupon.percentageDiscount, percentageDiscount.toString()), eq(merchantCoupon.type, "special"))
+      }) : null;
+      if (!merchantCouponResult) {
+        return [];
+      }
+      const codesArray = [];
+      const requestedQuantity = Number(input.quantity);
+      const couponQuantity = requestedQuantity < 0 ? 1 : requestedQuantity;
+      await client.transaction(async (trx) => {
+        for (let i = 0; i < couponQuantity; i++) {
+          const id = `coupon_${guid()}`;
+          await trx.insert(coupon).values({
+            ...input,
+            merchantCouponId: merchantCouponResult.id,
+            id
+          });
+          codesArray.push(id);
+        }
+      });
+      return codesArray;
+    }
+  };
+}
+__name(createCouponPort, "createCouponPort");
+
+export {
+  createCouponPort
+};
+//# sourceMappingURL=chunk-EAXC4CQD.js.map

package/dist/chunk-EDDG2YFS.js

@@ -0,0 +1,249 @@
+import {
+  guid
+} from "./chunk-6XQ6C3IX.js";
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/workflows/create-event-series.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 createEventSeriesWorkflow({ client, tables }, operations) {
+  const { contentResource, contentResourceResource, contentResourceTag } = tables;
+  return {
+    async createEventSeries(input, userId) {
+      const { eventSeries: eventSeriesInput, childEvents: childEventsInput } = input;
+      if (childEventsInput.length === 0) {
+        throw new Error("At least one event is required");
+      }
+      const result = await client.transaction(async (tx) => {
+        const eventSeriesHash = guid();
+        const eventSeriesResourceId = slugify(`event-series~${eventSeriesHash}`);
+        const newEventSeries = {
+          id: eventSeriesResourceId,
+          type: "event-series",
+          fields: {
+            ...eventSeriesInput.fields,
+            title: eventSeriesInput.fields.title,
+            state: "draft",
+            visibility: "public",
+            slug: slugify(`${eventSeriesInput.fields.title}~${eventSeriesHash}`)
+          },
+          createdById: userId
+        };
+        await tx.insert(contentResource).values(newEventSeries);
+        const eventSeriesResource = await tx.query.contentResource.findFirst({
+          where: eq(contentResource.id, eventSeriesResourceId),
+          with: {
+            resources: {
+              with: {
+                resource: {
+                  with: {
+                    resources: {
+                      with: {
+                        resource: true
+                      },
+                      orderBy: asc(contentResourceResource.position)
+                    }
+                  }
+                }
+              },
+              orderBy: asc(contentResourceResource.position)
+            },
+            tags: {
+              with: {
+                tag: true
+              },
+              orderBy: asc(contentResourceTag.position)
+            },
+            resourceProducts: {
+              with: {
+                product: {
+                  with: {
+                    price: true
+                  }
+                }
+              }
+            }
+          }
+        });
+        const parsedEventSeries = ContentResourceSchema.safeParse(eventSeriesResource);
+        if (!parsedEventSeries.success) {
+          throw new Error("Error parsing event series resource");
+        }
+        if (eventSeriesInput.fields.tagIds) {
+          await tx.insert(contentResourceTag).values(eventSeriesInput.fields.tagIds.map((tag) => ({
+            contentResourceId: eventSeriesResourceId,
+            tagId: tag.id,
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date(),
+            position: 0
+          })));
+        }
+        const createdChildEvents = [];
+        for (let i = 0; i < childEventsInput.length; i++) {
+          const childEventInput = childEventsInput[i];
+          if (!childEventInput) {
+            throw new Error(`Child event input is required`);
+          }
+          const childEventHash = guid();
+          const childEventResourceId = slugify(`event~${childEventHash}`);
+          const newChildEvent = {
+            id: childEventResourceId,
+            type: "event",
+            fields: {
+              title: childEventInput.fields.title,
+              startsAt: childEventInput.fields.startsAt,
+              endsAt: childEventInput.fields.endsAt,
+              description: childEventInput.fields.description,
+              state: "draft",
+              visibility: "public",
+              slug: slugify(`${childEventInput.fields.title}~${childEventHash}`),
+              // No price/quantity - they're on the event series
+              price: null,
+              quantity: null
+            },
+            createdById: userId
+          };
+          await tx.insert(contentResource).values(newChildEvent);
+          const childEventResource = await tx.query.contentResource.findFirst({
+            where: eq(contentResource.id, childEventResourceId),
+            with: {
+              resources: {
+                with: {
+                  resource: {
+                    with: {
+                      resources: {
+                        with: {
+                          resource: true
+                        },
+                        orderBy: asc(contentResourceResource.position)
+                      }
+                    }
+                  }
+                },
+                orderBy: asc(contentResourceResource.position)
+              },
+              tags: {
+                with: {
+                  tag: true
+                },
+                orderBy: asc(contentResourceTag.position)
+              },
+              resourceProducts: {
+                with: {
+                  product: {
+                    with: {
+                      price: true
+                    }
+                  }
+                }
+              }
+            }
+          });
+          const parsedChildEvent = ContentResourceSchema.safeParse(childEventResource);
+          if (!parsedChildEvent.success) {
+            throw new Error(`Error parsing child event resource ${i + 1}`);
+          }
+          if (childEventInput.fields.tagIds) {
+            await tx.insert(contentResourceTag).values(childEventInput.fields.tagIds.map((tag) => ({
+              contentResourceId: childEventResourceId,
+              tagId: tag.id,
+              createdAt: /* @__PURE__ */ new Date(),
+              updatedAt: /* @__PURE__ */ new Date(),
+              position: 0
+            })));
+          }
+          await tx.insert(contentResourceResource).values({
+            resourceOfId: eventSeriesResourceId,
+            resourceId: childEventResourceId,
+            position: i
+          });
+          createdChildEvents.push(parsedChildEvent.data);
+        }
+        return {
+          eventSeries: parsedEventSeries.data,
+          childEvents: createdChildEvents
+        };
+      });
+      const { eventSeries, childEvents } = result;
+      if (eventSeriesInput.sharedFields.price && eventSeriesInput.sharedFields.price > 0) {
+        try {
+          const product = await operations.createProduct({
+            name: eventSeriesInput.fields.title,
+            price: eventSeriesInput.sharedFields.price,
+            quantityAvailable: eventSeriesInput.sharedFields.quantity ?? -1,
+            type: "live",
+            state: "published",
+            visibility: "public"
+          });
+          if (product) {
+            await operations.addResourceToProduct({
+              resource: eventSeries,
+              productId: product.id,
+              userId
+            });
+            if (input.coupon?.enabled && input.coupon.percentageDiscount && input.coupon.expires) {
+              try {
+                let finalExpires = input.coupon.expires;
+                if (finalExpires instanceof Date) {
+                  finalExpires = new Date(Date.UTC(finalExpires.getUTCFullYear(), finalExpires.getUTCMonth(), finalExpires.getUTCDate(), 23, 59, 59, 0));
+                }
+                const couponInput = {
+                  quantity: "1",
+                  maxUses: 1,
+                  expires: finalExpires,
+                  restrictedToProductId: product.id,
+                  percentageDiscount: input.coupon.percentageDiscount,
+                  status: 1,
+                  default: true,
+                  fields: {}
+                };
+                await operations.createCoupon(couponInput);
+                logger.debug("event.series.coupon.success", {
+                  eventSeriesId: eventSeries.id,
+                  productId: product.id,
+                  userId,
+                  percentageDiscount: input.coupon.percentageDiscount
+                });
+              } catch (couponError) {
+                logger.error(new Error(`Error creating coupon for event series: ${couponError}`));
+                logger.debug("event.series.coupon.failed", {
+                  eventSeriesId: eventSeries.id,
+                  productId: product.id,
+                  userId
+                });
+              }
+            }
+          } else {
+            logger.error(new Error("Failed to create product"));
+            logger.debug("event.series.product.failed", {
+              eventSeriesId: eventSeries.id,
+              userId,
+              price: eventSeriesInput.sharedFields.price
+            });
+          }
+        } catch (error) {
+          logger.error(new Error(`Error creating and associating product: ${error}`));
+          logger.debug("event.series.product.creation.failed", {
+            eventSeriesId: eventSeries.id,
+            userId
+          });
+        }
+      }
+      return {
+        eventSeries,
+        childEvents
+      };
+    }
+  };
+}
+__name(createEventSeriesWorkflow, "createEventSeriesWorkflow");
+
+export {
+  createEventSeriesWorkflow
+};
+//# sourceMappingURL=chunk-EDDG2YFS.js.map