@coursebuilder/adapter-drizzle 2.1.1 → 3.0.0-canary.0.1de808999

package/dist/chunk-2TFZWYLS.js

@@ -0,0 +1,263 @@
+import {
+  __name
+} from "./chunk-H736K5TN.js";
+
+// src/lib/mysql/ports/progress.ts
+import { and, eq, inArray, or, sql } from "drizzle-orm";
+import { z } from "zod";
+import { resourceProgressSchema } from "@coursebuilder/core/schemas";
+import { logger as baseLogger } from "@coursebuilder/utils/logger";
+var logger = baseLogger;
+function createProgressPort({ client, tables }) {
+  const { contentResource, contentResourceResource, resourceProgress, users } = tables;
+  return {
+    async clearLessonProgressForUser(options) {
+      const lessonIds = options.lessons.map(({ id }) => id);
+      if (lessonIds.length === 0)
+        return;
+      await client.delete(resourceProgress).where(and(eq(resourceProgress.userId, options.userId), inArray(resourceProgress.resourceId, lessonIds)));
+    },
+    async completeLessonProgressForUser(options) {
+      if (!options.lessonId) {
+        throw new Error("No lessonId provided");
+      }
+      let lessonProgress = await client.query.resourceProgress.findFirst({
+        where: and(eq(resourceProgress.userId, options.userId), eq(resourceProgress.resourceId, options.lessonId))
+      });
+      const now = /* @__PURE__ */ new Date();
+      if (lessonProgress) {
+        if (!lessonProgress.completedAt) {
+          await client.update(resourceProgress).set({
+            completedAt: now,
+            updatedAt: now
+          }).where(and(eq(resourceProgress.userId, options.userId), eq(resourceProgress.resourceId, options.lessonId)));
+        }
+      } else {
+        await client.insert(resourceProgress).values({
+          userId: options.userId,
+          resourceId: options.lessonId,
+          completedAt: now,
+          updatedAt: now
+        });
+      }
+      lessonProgress = await client.query.resourceProgress.findFirst({
+        where: and(eq(resourceProgress.userId, options.userId), eq(resourceProgress.resourceId, options.lessonId))
+      });
+      const parsedLessonProgress = resourceProgressSchema.safeParse(lessonProgress);
+      if (!parsedLessonProgress.success) {
+        logger.error(parsedLessonProgress.error, {
+          event: "adapter.lessonProgress.parse_failed",
+          lessonId: options.lessonId,
+          userId: options.userId
+        });
+        return null;
+      }
+      return parsedLessonProgress.data;
+    },
+    async getLessonProgressCountsByDate() {
+      const completed = await client.select({
+        completedAt: resourceProgress.completedAt
+      }).from(resourceProgress).where(sql`${resourceProgress.completedAt} IS NOT NULL`);
+      const counts = /* @__PURE__ */ new Map();
+      for (const { completedAt } of completed) {
+        if (!completedAt)
+          continue;
+        const date = completedAt.toISOString().slice(0, 10);
+        counts.set(date, (counts.get(date) ?? 0) + 1);
+      }
+      return Array.from(counts, ([completedAt, count]) => ({
+        count,
+        completedAt
+      })).sort((left, right) => left.completedAt.localeCompare(right.completedAt));
+    },
+    async getLessonProgressForUser(userId) {
+      const userProgress = await client.query.resourceProgress.findMany({
+        where: eq(resourceProgress.userId, userId)
+      });
+      const parsed = z.array(resourceProgressSchema).safeParse(userProgress);
+      if (!parsed.success) {
+        logger.error(parsed.error, {
+          event: "adapter.userProgress.parse_failed",
+          userId
+        });
+        return [];
+      }
+      return parsed.data;
+    },
+    async getModuleProgressForUser(userIdOrEmail, moduleIdOrSlug) {
+      const user = await client.query.users.findFirst({
+        where: or(eq(users.id, userIdOrEmail), eq(users.email, userIdOrEmail)),
+        columns: {
+          id: true
+        }
+      });
+      if (!user) {
+        return null;
+      }
+      const ResultRowSchema = z.object({
+        resource_id: z.string(),
+        resource_type: z.enum([
+          "lesson",
+          "exercise",
+          "post"
+        ]),
+        resource_slug: z.string().nullable(),
+        completed_at: z.string().nullable().transform((val) => val ? new Date(val) : null)
+      });
+      const results = await client.execute(sql`
+				WITH RECURSIVE workshop AS (
+					SELECT id, fields->>'$.slug' AS slug
+					FROM ${contentResource}
+					WHERE id = ${moduleIdOrSlug} OR fields->>'$.slug' = ${moduleIdOrSlug}
+				),
+				-- Get all workshop resources with their positions
+				workshop_structure AS (
+					SELECT
+						w.id AS workshop_id,
+						crr.resourceId,
+						crr.position AS position,
+						cr.type AS resource_type,
+						cr.fields->>'$.slug' AS resource_slug,
+						cr.id AS resource_content_id
+					FROM workshop w
+					JOIN ${contentResourceResource} crr ON w.id = crr.resourceOfId
+					JOIN ${contentResource} cr ON crr.resourceId = cr.id
+					ORDER BY crr.position
+				),
+				-- Recursively expand sections and maintain global ordering
+				expanded_resources AS (
+					-- Base case: direct lessons/posts from workshop
+					SELECT
+						workshop_id,
+						position * 1000 AS global_order, -- Multiply by 1000 to leave room for section items
+						resource_content_id AS resource_id,
+						resource_type,
+						resource_slug
+					FROM workshop_structure
+					WHERE resource_type IN ('lesson', 'post')
+					UNION ALL
+					-- Recursive case: lessons within sections
+					SELECT
+						ws.workshop_id,
+						ws.position * 1000 + crr.position AS global_order, -- Section position * 1000 + lesson position
+						cr.id AS resource_id,
+						cr.type AS resource_type,
+						cr.fields->>'$.slug' AS resource_slug
+					FROM workshop_structure ws
+					JOIN ${contentResourceResource} crr ON ws.resource_content_id = crr.resourceOfId
+					JOIN ${contentResource} cr ON crr.resourceId = cr.id
+					WHERE ws.resource_type = 'section'
+					AND cr.type IN ('lesson', 'post')
+				)
+				SELECT
+					er.resource_id,
+					er.resource_type,
+					er.resource_slug,
+					rp.completedAt AS completed_at,
+					er.global_order
+				FROM expanded_resources er
+				LEFT JOIN ${resourceProgress} rp ON rp.resourceId = er.resource_id
+					AND rp.userId = ${user.id}
+				ORDER BY er.global_order ASC
+			`);
+      const rows = Array.isArray(results) ? results[0] : results.rows;
+      const completedLessons = [];
+      let nextResource = null;
+      let completedLessonsCount = 0;
+      let totalLessonsCount = rows.length;
+      const parsedRows = z.array(ResultRowSchema).safeParse(rows);
+      if (!parsedRows.success) {
+        logger.error(parsedRows.error, {
+          event: "adapter.moduleProgress.rows.parse_failed",
+          moduleIdOrSlug,
+          userId: user.id
+        });
+        return {
+          completedLessons: [],
+          nextResource: null,
+          percentCompleted: 0,
+          completedLessonsCount: 0,
+          totalLessonsCount
+        };
+      }
+      for (const row of parsedRows.data) {
+        if (row.completed_at) {
+          completedLessonsCount++;
+          completedLessons.push({
+            userId: user.id,
+            resourceId: row.resource_id,
+            completedAt: new Date(row.completed_at)
+          });
+        } else if (!nextResource) {
+          nextResource = {
+            id: row.resource_id,
+            type: row.resource_type,
+            fields: {
+              slug: row.resource_slug
+            }
+          };
+        }
+      }
+      const percentCompleted = totalLessonsCount > 0 ? Math.ceil(completedLessonsCount / totalLessonsCount * 100) : 0;
+      return {
+        completedLessons,
+        nextResource,
+        percentCompleted,
+        completedLessonsCount,
+        totalLessonsCount
+      };
+    },
+    async getLessonProgresses() {
+      const progresses = await client.query.resourceProgress.findMany();
+      const parsed = z.array(resourceProgressSchema).safeParse(progresses);
+      if (!parsed.success) {
+        logger.error(parsed.error, {
+          event: "adapter.lessonProgresses.parse_failed"
+        });
+        return [];
+      }
+      return parsed.data;
+    },
+    async toggleLessonProgressForUser(options) {
+      if (!options.lessonId) {
+        throw new Error("No lessonId provided");
+      }
+      let lessonProgress = await client.query.resourceProgress.findFirst({
+        where: and(eq(resourceProgress.userId, options.userId), eq(resourceProgress.resourceId, options.lessonId))
+      });
+      const now = /* @__PURE__ */ new Date();
+      if (lessonProgress) {
+        await client.update(resourceProgress).set({
+          completedAt: lessonProgress.completedAt ? null : now,
+          updatedAt: now
+        }).where(and(eq(resourceProgress.userId, options.userId), eq(resourceProgress.resourceId, options.lessonId)));
+      } else {
+        await client.insert(resourceProgress).values({
+          userId: options.userId,
+          resourceId: options.lessonId,
+          completedAt: now,
+          updatedAt: now
+        });
+      }
+      lessonProgress = await client.query.resourceProgress.findFirst({
+        where: and(eq(resourceProgress.userId, options.userId), eq(resourceProgress.resourceId, options.lessonId))
+      });
+      const parsedLessonProgress = resourceProgressSchema.safeParse(lessonProgress);
+      if (!parsedLessonProgress.success) {
+        logger.error(parsedLessonProgress.error, {
+          event: "adapter.lessonProgress.parse_failed",
+          lessonId: options.lessonId,
+          userId: options.userId
+        });
+        return null;
+      }
+      return parsedLessonProgress.data;
+    }
+  };
+}
+__name(createProgressPort, "createProgressPort");
+
+export {
+  createProgressPort
+};
+//# sourceMappingURL=chunk-2TFZWYLS.js.map

package/dist/chunk-3TRWZHL3.js

@@ -0,0 +1,243 @@
+import {
+  __name
+} from "./chunk-H736K5TN.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 { z } from "zod";
+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(z.object({
+        redeemedBulkCouponPurchases: z.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 z.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-3TRWZHL3.js.map

package/dist/chunk-4N2ECEUV.js

@@ -0,0 +1,69 @@
+import {
+  __name
+} from "./chunk-H736K5TN.js";
+
+// src/lib/mysql/ports/entitlement.ts
+import { and, asc, eq, gte, isNull, or, sql } from "drizzle-orm";
+import { z } from "zod";
+import { entitlementSchema } from "@coursebuilder/core/schemas";
+import { logger as baseLogger } from "@coursebuilder/utils/logger";
+var logger = baseLogger;
+function createEntitlementPort({ client, tables }) {
+  const { entitlements: entitlementTable, entitlementTypes } = tables;
+  return {
+    async getEntitlementsForUser(params) {
+      const { userId, sourceType, entitlementType } = params;
+      if (!userId) {
+        return [];
+      }
+      const conditions = [
+        eq(entitlementTable.userId, userId)
+      ];
+      if (sourceType) {
+        conditions.push(eq(entitlementTable.sourceType, sourceType));
+      }
+      if (entitlementType) {
+        conditions.push(eq(entitlementTable.entitlementType, entitlementType));
+      }
+      conditions.push(isNull(entitlementTable.deletedAt));
+      const expiresCondition = or(isNull(entitlementTable.expiresAt), gte(entitlementTable.expiresAt, sql`CURRENT_TIMESTAMP`));
+      if (expiresCondition) {
+        conditions.push(expiresCondition);
+      }
+      const userEntitlements = await client.query.entitlements.findMany({
+        where: conditions.length > 0 ? and(...conditions) : void 0,
+        orderBy: asc(entitlementTable.createdAt)
+      });
+      const parsedEntitlements = z.array(entitlementSchema).safeParse(userEntitlements);
+      if (!parsedEntitlements.success) {
+        logger.error(parsedEntitlements.error, {
+          entitlementCount: userEntitlements.length,
+          entitlementType,
+          event: "adapter.entitlement.list.parse_failed",
+          sourceType,
+          userId
+        });
+        return [];
+      }
+      return parsedEntitlements.data;
+    },
+    async getEntitlementTypeByName(name) {
+      const entitlementType = await client.query.entitlementTypes.findFirst({
+        where: eq(entitlementTypes.name, name)
+      });
+      if (!entitlementType) {
+        return null;
+      }
+      return {
+        id: String(entitlementType.id),
+        name: String(entitlementType.name)
+      };
+    }
+  };
+}
+__name(createEntitlementPort, "createEntitlementPort");
+
+export {
+  createEntitlementPort
+};
+//# sourceMappingURL=chunk-4N2ECEUV.js.map

package/dist/{chunk-F56AI52P.js → chunk-63MYTNFA.js}

@@ -1,9 +1,9 @@
 import {
   getUsersSchema
-} from "./chunk-PNPTKVJ4.js";
+} from "./chunk-QGSAYLPA.js";
 import {
   __name
-} from "./chunk-2X5XVNDN.js";
+} from "./chunk-H736K5TN.js";
 
 // src/lib/mysql/schemas/auth/sessions.ts
 import { relations } from "drizzle-orm";
@@ -46,4 +46,4 @@ export {
   getSessionsSchema,
   getSessionRelationsSchema
 };
-//# sourceMappingURL=chunk-F56AI52P.js.map
+//# sourceMappingURL=chunk-63MYTNFA.js.map

package/dist/{chunk-SIZFEXIS.js → chunk-6MRFUIH5.js}

@@ -1,6 +1,6 @@
 import {
   __name
-} from "./chunk-2X5XVNDN.js";
+} from "./chunk-H736K5TN.js";
 
 // src/lib/mysql/schemas/commerce/merchant-customer.ts
 import { sql } from "drizzle-orm";
@@ -46,4 +46,4 @@ __name(getMerchantCustomerSchema, "getMerchantCustomerSchema");
 export {
   getMerchantCustomerSchema
 };
-//# sourceMappingURL=chunk-SIZFEXIS.js.map
+//# sourceMappingURL=chunk-6MRFUIH5.js.map