@coursebuilder/adapter-drizzle 0.4.0 → 0.5.1

package/dist/{chunk-A26D3TCA.js → chunk-VUS77FG3.js}

@@ -1,28 +1,41 @@
+import {
+  getLessonProgressSchema
+} from "./chunk-YVVXDJHI.js";
 import {
   getResourceProgressSchema
-} from "./chunk-FNYW3XKR.js";
+} from "./chunk-XIGJFVUM.js";
+import {
+  getPurchaseUserTransferRelationsSchema,
+  getPurchaseUserTransferSchema
+} from "./chunk-DAP5KOAO.js";
 import {
   getUpgradableProductsRelationsSchema,
   getUpgradableProductsSchema
-} from "./chunk-ULEUIL2Y.js";
+} from "./chunk-7ISZNMPU.js";
 import {
-  getPurchaseUserTransferRelationsSchema,
-  getPurchaseUserTransferSchema
-} from "./chunk-IDINCRHK.js";
+  getRolePermissionsRelationsSchema,
+  getRolePermissionsSchema
+} from "./chunk-QPXUGIXO.js";
 import {
   getSessionRelationsSchema,
   getSessionsSchema
-} from "./chunk-DL3UMWB4.js";
+} from "./chunk-7X7TMG4A.js";
 import {
   getVerificationTokensSchema
-} from "./chunk-MBB4GIJI.js";
+} from "./chunk-LERR6HQ3.js";
 import {
-  getRolePermissionsRelationsSchema,
-  getRolePermissionsSchema
-} from "./chunk-XJHSXR42.js";
+  getDeviceAccessTokenRelationsSchema,
+  getDeviceAccessTokenSchema
+} from "./chunk-UK6EHYS5.js";
+import {
+  getDeviceVerificationRelationsSchema,
+  getDeviceVerificationSchema
+} from "./chunk-KDOSK7KN.js";
 import {
   getAccountsRelationsSchema,
   getAccountsSchema,
+  getCommentRelationsSchema,
+  getCommentsSchema,
   getCommunicationPreferencesRelationsSchema,
   getCommunicationPreferencesSchema,
   getContentContributionRelationsSchema,
@@ -44,55 +57,59 @@ import {
   getRolesSchema,
   getUserPermissionsRelationsSchema,
   getUserPermissionsSchema,
+  getUserPrefsRelationsSchema,
+  getUserPrefsSchema,
   getUserRolesRelationsSchema,
   getUserRolesSchema,
   getUsersRelationsSchema,
   getUsersSchema
-} from "./chunk-N7UDJAI3.js";
+} from "./chunk-UHH4OVKA.js";
 import {
   getContributionTypesRelationsSchema,
   getContributionTypesSchema
-} from "./chunk-GLPDG7UE.js";
+} from "./chunk-KDEWFXEP.js";
 import {
   getCommunicationChannelSchema
-} from "./chunk-J4LBG2TH.js";
+} from "./chunk-GINRTL6J.js";
 import {
   getCommunicationPreferenceTypesSchema
-} from "./chunk-BX5SO2JG.js";
-import {
-  getMerchantCouponSchema
-} from "./chunk-JKOYOL7A.js";
-import {
-  getMerchantPriceSchema
-} from "./chunk-PPBEA4EM.js";
-import {
-  getMerchantSessionSchema
-} from "./chunk-V23SCQL7.js";
+} from "./chunk-P4VXXTVA.js";
 import {
   getMerchantChargeRelationsSchema,
   getMerchantChargeSchema
-} from "./chunk-ZD3R6UPJ.js";
+} from "./chunk-SRTIWWLG.js";
+import {
+  getMerchantAccountSchema
+} from "./chunk-QP6YMUQX.js";
+import {
+  getMerchantCouponSchema
+} from "./chunk-YGRYHMCG.js";
 import {
   getMerchantCustomerSchema
-} from "./chunk-57CX5SOI.js";
+} from "./chunk-2UU2F4DM.js";
+import {
+  getMerchantPriceSchema
+} from "./chunk-6ON2O6UD.js";
 import {
   getMerchantProductSchema
-} from "./chunk-Y7QZGEPT.js";
+} from "./chunk-4ZWS76VQ.js";
 import {
-  getMerchantAccountSchema
-} from "./chunk-VXZRMVNY.js";
+  getMerchantSessionSchema
+} from "./chunk-3NUCFLQJ.js";
 import {
   getPermissionsRelationsSchema,
   getPermissionsSchema
-} from "./chunk-VDVCCU7D.js";
+} from "./chunk-LZHZDFNZ.js";
 import {
   __name
 } from "./chunk-H736K5TN.js";
 
 // src/lib/mysql/index.ts
+import slugify from "@sindresorhus/slugify";
 import { addSeconds, isAfter } from "date-fns";
-import { and, asc, desc, eq, gte, inArray, isNotNull, isNull, not, or, sql } from "drizzle-orm";
+import { and, asc, desc, eq, gte, inArray, isNull, not, or, sql } from "drizzle-orm";
 import { mysqlTable as defaultMySqlTableFn } from "drizzle-orm/mysql-core";
+import { customAlphabet } from "nanoid";
 import { v4 } from "uuid";
 
 // ../../node_modules/.pnpm/zod@3.22.4/node_modules/zod/lib/index.mjs
@@ -8108,6 +8125,29 @@ var z2 = /* @__PURE__ */ Object.freeze({
   ZodError: ZodError2
 });
 
+// ../core/dist/chunk-CMH4QQ3R.js
+var VideoResourceSchema = z2.object({
+  id: z2.string(),
+  updatedAt: z2.coerce.date().optional(),
+  createdAt: z2.coerce.date().optional(),
+  title: z2.string().optional().nullable(),
+  duration: z2.number().optional().nullable(),
+  muxPlaybackId: z2.string().optional().nullable(),
+  muxAssetId: z2.string().optional().nullable(),
+  transcript: z2.string().optional().nullable(),
+  transcriptWithScreenshots: z2.string().optional().nullable(),
+  srt: z2.string().optional().nullable(),
+  wordLevelSrt: z2.string().optional().nullable(),
+  state: z2.enum([
+    "new",
+    "processing",
+    "preparing",
+    "ready",
+    "errored",
+    "deleted"
+  ])
+});
+
 // ../core/dist/chunk-CHYUPSYW.js
 var userSchema = z2.object({
   id: z2.string().max(255),
@@ -8142,15 +8182,15 @@ var priceSchema = z2.object({
   fields: z2.record(z2.any()).default({})
 });
 
-// ../core/dist/chunk-YYIPQN6H.js
+// ../core/dist/chunk-5BAEWUNU.js
 var ContentResourceResourceSchema = z2.object({
   resourceId: z2.string(),
   resourceOfId: z2.string(),
   position: z2.number().default(0),
   metadata: z2.record(z2.string(), z2.any()).default({}).nullable(),
-  createdAt: z2.date().nullable(),
-  updatedAt: z2.date().nullable(),
-  deletedAt: z2.date().nullable(),
+  createdAt: z2.coerce.date().nullable(),
+  updatedAt: z2.coerce.date().nullable(),
+  deletedAt: z2.coerce.date().nullable(),
   resource: z2.any()
 });
 var ContentResourceSchema = z2.object({
@@ -8158,9 +8198,9 @@ var ContentResourceSchema = z2.object({
   type: z2.string(),
   createdById: z2.string(),
   fields: z2.record(z2.string(), z2.any()).default({}).nullable().optional(),
-  createdAt: z2.date().nullable(),
-  updatedAt: z2.date().nullable(),
-  deletedAt: z2.date().nullable(),
+  createdAt: z2.coerce.date().nullable(),
+  updatedAt: z2.coerce.date().nullable(),
+  deletedAt: z2.coerce.date().nullable(),
   resources: z2.array(ContentResourceResourceSchema).default([]).nullable()
 });
 var ContentResourceProductSchema = z2.object({
@@ -8168,9 +8208,9 @@ var ContentResourceProductSchema = z2.object({
   productId: z2.string(),
   position: z2.number().default(0),
   metadata: z2.record(z2.string(), z2.any()).default({}).nullable(),
-  createdAt: z2.date().nullable(),
-  updatedAt: z2.date().nullable(),
-  deletedAt: z2.date().nullable(),
+  createdAt: z2.coerce.date().nullable(),
+  updatedAt: z2.coerce.date().nullable(),
+  deletedAt: z2.coerce.date().nullable(),
   resource: z2.any(),
   product: z2.any()
 });
@@ -8186,7 +8226,7 @@ var ResourceVisibilitySchema = z2.union([
   z2.literal("unlisted")
 ]);
 
-// ../core/dist/chunk-DGMGNBW7.js
+// ../core/dist/chunk-SVQMPVCK.js
 var productSchema = z2.object({
   id: z2.string().max(191),
   name: z2.string().max(191),
@@ -8197,10 +8237,10 @@ var productSchema = z2.object({
   ]).default("self-paced"),
   fields: z2.object({
     body: z2.string().nullable().optional(),
-    description: z2.string().optional().nullable(),
+    description: z2.string().nullish(),
     slug: z2.string(),
     image: z2.object({
-      url: z2.string().url(),
+      url: z2.string(),
       alt: z2.string().optional().nullable(),
       width: z2.number().optional().nullable(),
       height: z2.number().optional().nullable()
@@ -8218,14 +8258,19 @@ var productSchema = z2.object({
       "unlisted"
     ]).default("unlisted")
   }),
-  createdAt: z2.date().nullable(),
+  createdAt: z2.coerce.date().nullable(),
   status: z2.number().int().default(0),
   quantityAvailable: z2.number().int().default(-1),
   price: priceSchema.nullable().optional(),
   resources: z2.array(ContentResourceProductSchema).default([]).nullable()
 });
+var NewProductSchema = z2.object({
+  name: z2.string().min(2).max(90),
+  quantityAvailable: z2.coerce.number().default(-1),
+  price: z2.coerce.number().gte(0).default(0)
+});
 
-// ../core/dist/chunk-VDB4YSMY.js
+// ../core/dist/chunk-RCFZC3SN.js
 var couponSchema = z2.object({
   id: z2.string(),
   code: z2.string().max(191).optional().nullable(),
@@ -8242,11 +8287,12 @@ var couponSchema = z2.object({
     return decimalPlaces <= 2;
   }),
   restrictedToProductId: z2.string().max(191).optional().nullable(),
-  bulkPurchaseId: z2.string().max(191).optional().nullable(),
-  bulkCouponPurchases: z2.any().optional().nullable()
+  bulkPurchases: z2.array(z2.any()).default([]),
+  redeemedBulkCouponPurchases: z2.array(z2.any()).default([]),
+  bulkPurchaseId: z2.string().max(191).optional().nullable()
 });
 
-// ../core/dist/chunk-OUYYSWMK.js
+// ../core/dist/chunk-5OFQV6YX.js
 var purchaseSchema = z2.object({
   id: z2.string().max(191),
   userId: z2.string().max(191).optional().nullable(),
@@ -8295,18 +8341,15 @@ var purchaseUserTransferSchema = z2.object({
   completedAt: z2.date().nullable()
 });
 
-// ../core/dist/chunk-GCYJ74DO.js
+// ../core/dist/chunk-CWQHSOPP.js
 var resourceProgressSchema = z2.object({
   userId: z2.string().max(191),
-  contentResourceId: z2.string().max(191).optional().nullable(),
-  fields: z2.record(z2.any()).default({}),
-  completedAt: z2.date().nullable(),
-  updatedAt: z2.date().nullable(),
-  createdAt: z2.date().nullable()
+  resourceId: z2.string().max(191).optional().nullable(),
+  completedAt: z2.date().nullable()
 });
 var moduleProgressSchema = z2.object({
   completedLessons: z2.array(resourceProgressSchema),
-  nextResource: ContentResourceSchema.nullable(),
+  nextResource: ContentResourceSchema.partial().nullable(),
   percentCompleted: z2.number().default(0),
   completedLessonsCount: z2.number().default(0),
   totalLessonsCount: z2.number().default(0)
@@ -8323,28 +8366,6 @@ var upgradableProductSchema = z2.object({
   deletedAt: z2.date().nullable()
 });
 
-// ../core/dist/chunk-G22WGQ3G.js
-var VideoResourceSchema = z2.object({
-  id: z2.string(),
-  updatedAt: z2.string().optional(),
-  createdAt: z2.string().optional(),
-  title: z2.string().optional().nullable(),
-  duration: z2.number().optional().nullable(),
-  muxPlaybackId: z2.string().optional().nullable(),
-  muxAssetId: z2.string().optional().nullable(),
-  transcript: z2.string().optional().nullable(),
-  transcriptWithScreenshots: z2.string().optional().nullable(),
-  srt: z2.string().optional().nullable(),
-  wordLevelSrt: z2.string().optional().nullable(),
-  state: z2.enum([
-    "new",
-    "processing",
-    "preparing",
-    "ready",
-    "errored"
-  ])
-});
-
 // ../core/dist/chunk-EDDT2FFU.js
 var merchantCustomerSchema = z2.object({
   id: z2.string().max(191),
@@ -8540,6 +8561,7 @@ var validateCoupon = /* @__PURE__ */ __name2((coupon, productIds = []) => {
 }, "validateCoupon");
 
 // src/lib/mysql/index.ts
+var guid = customAlphabet("1234567890abcdefghijklmnopqrstuvwxyz", 5);
 function getCourseBuilderSchema(mysqlTable) {
   return {
     accounts: getAccountsSchema(mysqlTable),
@@ -8561,6 +8583,7 @@ function getCourseBuilderSchema(mysqlTable) {
     verificationTokens: getVerificationTokensSchema(mysqlTable),
     coupon: getCouponSchema(mysqlTable),
     couponRelations: getCouponRelationsSchema(mysqlTable),
+    lessonProgress: getLessonProgressSchema(mysqlTable),
     merchantAccount: getMerchantAccountSchema(mysqlTable),
     merchantCharge: getMerchantChargeSchema(mysqlTable),
     merchantChargeRelations: getMerchantChargeRelationsSchema(mysqlTable),
@@ -8592,7 +8615,15 @@ function getCourseBuilderSchema(mysqlTable) {
     upgradableProductsRelations: getUpgradableProductsRelationsSchema(mysqlTable),
     contentResourceProduct: getContentResourceProductSchema(mysqlTable),
     contentResourceProductRelations: getContentResourceProductRelationsSchema(mysqlTable),
-    productRelations: getProductRelationsSchema(mysqlTable)
+    productRelations: getProductRelationsSchema(mysqlTable),
+    comments: getCommentsSchema(mysqlTable),
+    commentsRelations: getCommentRelationsSchema(mysqlTable),
+    deviceVerifications: getDeviceVerificationSchema(mysqlTable),
+    deviceVerificationRelations: getDeviceVerificationRelationsSchema(mysqlTable),
+    deviceAccessToken: getDeviceAccessTokenSchema(mysqlTable),
+    deviceAccessTokenRelations: getDeviceAccessTokenRelationsSchema(mysqlTable),
+    userPrefs: getUserPrefsSchema(mysqlTable),
+    userPrefsRelations: getUserPrefsRelationsSchema(mysqlTable)
   };
 }
 __name(getCourseBuilderSchema, "getCourseBuilderSchema");
@@ -8600,8 +8631,8 @@ function createTables(mySqlTable) {
   return getCourseBuilderSchema(mySqlTable);
 }
 __name(createTables, "createTables");
-function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
-  const { users, accounts, sessions, verificationTokens, contentResource, contentResourceResource, purchases: purchaseTable, purchaseUserTransfer, coupon, merchantCoupon, merchantCharge, merchantAccount, merchantPrice, merchantCustomer, merchantSession, merchantProduct, prices, products, upgradableProducts, resourceProgress } = createTables(tableFn);
+function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn, paymentProvider) {
+  const { users, accounts, sessions, verificationTokens, contentResource, contentResourceResource, contentResourceProduct, purchases: purchaseTable, purchaseUserTransfer, coupon, merchantCoupon, merchantCharge, merchantAccount, merchantPrice, merchantCustomer, merchantSession, merchantProduct, prices, products, upgradableProducts, resourceProgress, comments } = createTables(tableFn);
   const adapter = {
     client,
     async redeemFullPriceCoupon(options) {
@@ -8613,7 +8644,7 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
         throw new Error(`unable-to-find-any-product-id`);
       const couponValidation = validateCoupon(coupon2, productIds);
       if (coupon2 && couponValidation.isRedeemable) {
-        const bulkCouponRedemption = Boolean(coupon2.bulkPurchase?.bulkCouponId);
+        const bulkCouponRedemption = Boolean(coupon2.maxUses > 1);
         const { user } = await adapter.findOrCreateUser(email);
         if (!user)
           throw new Error(`unable-to-create-user-${email}`);
@@ -8623,8 +8654,18 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
           userId: user.id,
           productId
         });
-        if (existingPurchases.length > 0)
-          throw new Error(`already-purchased-${email}`);
+        if (existingPurchases.length > 0) {
+          const errorMessage = `already-purchased-${email}`;
+          console.error(errorMessage);
+          return {
+            error: {
+              message: errorMessage
+            },
+            redeemingForCurrentUser,
+            purchase: null
+          };
+          throw new Error(errorMessage);
+        }
         const purchaseId = `purchase-${v4()}`;
         await adapter.createPurchase({
           id: purchaseId,
@@ -8690,7 +8731,7 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
     },
     getMerchantPriceForProductId: async (productId) => {
       const merchantPriceData = await client.query.merchantPrice.findFirst({
-        where: eq(merchantPrice.merchantProductId, productId)
+        where: and(eq(merchantPrice.merchantProductId, productId), eq(merchantPrice.status, 1))
       });
       const parsedMerchantPrice = merchantPriceSchema.safeParse(merchantPriceData);
       if (!parsedMerchantPrice.success) {
@@ -8724,7 +8765,7 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
     async availableUpgradesForProduct(purchases, productId) {
       const previousPurchaseProductIds = purchases.map(({ productId: productId2 }) => productId2);
       if (previousPurchaseProductIds.length > 0) {
-        return await client.query.upgradableProducts.findMany({
+        return client.query.upgradableProducts.findMany({
           where: and(eq(upgradableProducts.upgradableToId, productId), inArray(upgradableProducts.upgradableFromId, previousPurchaseProductIds))
         });
       }
@@ -8738,7 +8779,7 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
         throw new Error("No lessonId provided");
       }
       let lessonProgress = await client.query.resourceProgress.findFirst({
-        where: and(eq(resourceProgress.userId, options.userId), eq(resourceProgress.contentResourceId, options.lessonId))
+        where: and(eq(resourceProgress.userId, options.userId), eq(resourceProgress.resourceId, options.lessonId))
       });
       const now = /* @__PURE__ */ new Date();
       if (lessonProgress) {
@@ -8746,18 +8787,18 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
           await client.update(resourceProgress).set({
             completedAt: now,
             updatedAt: now
-          }).where(eq(resourceProgress.contentResourceId, options.lessonId));
+          }).where(eq(resourceProgress.resourceId, options.lessonId));
         }
       } else {
         await client.insert(resourceProgress).values({
           userId: options.userId,
-          contentResourceId: options.lessonId,
+          resourceId: options.lessonId,
           completedAt: now,
           updatedAt: now
         });
       }
       lessonProgress = await client.query.resourceProgress.findFirst({
-        where: and(eq(resourceProgress.userId, options.userId), eq(resourceProgress.contentResourceId, options.lessonId))
+        where: and(eq(resourceProgress.userId, options.userId), eq(resourceProgress.resourceId, options.lessonId))
       });
       const parsedLessonProgress = resourceProgressSchema.safeParse(lessonProgress);
       if (!parsedLessonProgress.success) {
@@ -8777,9 +8818,14 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
       });
       if (!couponForIdOrCode)
         return null;
-      return couponSchema.extend({
+      const parsedCoupon = couponSchema.extend({
         merchantCoupon: merchantCouponSchema
-      }).parse(couponForIdOrCode);
+      }).safeParse(couponForIdOrCode);
+      if (!parsedCoupon.success) {
+        console.error("Error parsing coupon", JSON.stringify(parsedCoupon.error));
+        return null;
+      }
+      return parsedCoupon.data;
     },
     async createMerchantChargeAndPurchase(options) {
       const purchaseId = await client.transaction(async (trx) => {
@@ -8816,7 +8862,7 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
             ]))
           }) || null);
           const existingBulkCoupon = couponSchema.nullable().parse(await client.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))).then((res) => {
-            return res[0]?.coupons ?? null;
+            return res[0]?.Coupon ?? null;
           }));
           const isBulkPurchase = quantity > 1 || Boolean(existingBulkCoupon) || options.bulk || Boolean(existingPurchase?.status === "Valid");
           let bulkCouponId = null;
@@ -8941,18 +8987,31 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
         couponId
       });
       let couponData;
+      let bulkCouponPurchases;
       try {
         couponData = await client.query.coupon.findFirst({
           where: eq(coupon.id, couponId),
           with: {
-            bulkPurchase: true,
-            bulkCouponPurchases: true
+            bulkPurchases: true,
+            redeemedBulkCouponPurchases: true
           }
         }) || null;
       } catch (e) {
         console.log("getCouponWithBulkPurchases");
         logger.error(e);
       }
+      try {
+        bulkCouponPurchases = await client.query.purchases.findMany({
+          where: eq(purchaseTable.redeemedBulkCouponId, couponId),
+          with: {
+            user: true
+          }
+        });
+        console.log("purchases with redeemedBulkCouponId", bulkCouponPurchases);
+      } catch (e) {
+        console.log("getCouponWithBulkPurchases");
+        logger.error(e);
+      }
       if (!couponData) {
         logger.debug("getCouponWithBulkPurchases", {
           couponId,
@@ -8960,12 +9019,15 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
         });
         return null;
       }
+      const couponWithBulkPurchases = {
+        ...couponData,
+        redeemedBulkCouponPurchases: bulkCouponPurchases || []
+      };
       const parsedCoupon = couponSchema.merge(z.object({
-        bulkCouponPurchases: z.array(purchaseSchema),
-        bulkPurchase: purchaseSchema.nullable().optional()
-      })).nullable().safeParse(couponData);
+        redeemedBulkCouponPurchases: z.array(purchaseSchema)
+      })).nullable().safeParse(couponWithBulkPurchases);
       if (!parsedCoupon.success) {
-        console.error("Error parsing coupon", couponData);
+        console.error("Error parsing coupon", JSON.stringify(parsedCoupon.error), couponData);
         return null;
       }
       return parsedCoupon.data;
@@ -9007,95 +9069,98 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
       return parsed.data;
     },
     async getModuleProgressForUser(userIdOrEmail, moduleIdOrSlug) {
-      const module = await client.query.contentResource.findFirst({
-        where: or(eq(contentResource.id, moduleIdOrSlug), eq(sql`JSON_EXTRACT (${contentResource.fields}, "$.slug")`, moduleIdOrSlug)),
-        with: {
-          resources: {
-            orderBy: asc(contentResourceResource.position)
-          }
-        }
-      });
-      const parsedModule = ContentResourceSchema.parse(module);
-      const moduleResources = await client.query.contentResourceResource.findMany({
-        where: inArray(contentResourceResource.resourceOfId, parsedModule.resources?.map((r) => r.resourceId) ?? []),
-        orderBy: asc(contentResourceResource.position)
-      });
-      const parsedModuleResources = z.array(ContentResourceResourceSchema).safeParse(moduleResources);
-      if (!parsedModuleResources.success) {
-        console.error("Error parsing module resources", parsedModuleResources.error);
-        return {
-          completedLessons: [],
-          nextResource: null,
-          percentCompleted: 0,
-          completedLessonsCount: 0,
-          totalLessonsCount: 0
-        };
-      }
       const user = await client.query.users.findFirst({
         where: or(eq(users.id, userIdOrEmail), eq(users.email, userIdOrEmail)),
-        with: {
-          roles: {
-            with: {
-              role: true
-            }
-          }
-        }
-      }).then(async (res) => {
-        if (res) {
-          return {
-            ...res,
-            roles: res.roles.map((r) => r.role)
-          };
+        columns: {
+          id: true
         }
       });
       if (!user) {
-        console.error("User not found", userIdOrEmail);
-        return {
-          completedLessons: [],
-          nextResource: null,
-          percentCompleted: 0,
-          completedLessonsCount: 0,
-          totalLessonsCount: parsedModuleResources.data.length
-        };
+        return null;
       }
-      const parsedUser = userSchema.safeParse(user);
-      if (!parsedUser.success) {
-        console.error("Error parsing user", parsedUser.error);
+      const ResultRowSchema = z.object({
+        resource_id: z.string(),
+        resource_type: z.enum([
+          "lesson",
+          "exercise"
+        ]),
+        resource_slug: z.string().nullable(),
+        completed_at: z.string().nullable().transform((val) => val ? new Date(val) : null)
+      });
+      const results = await client.execute(sql`
+        SELECT
+						cr.id AS resource_id,
+						cr.type AS resource_type,
+						cr.fields->>'$.slug' AS resource_slug,
+						rp.completedAt AS completed_at
+				FROM
+						(SELECT id, fields->>'$.slug' AS slug
+						 FROM ${contentResource}
+						 WHERE id = ${moduleIdOrSlug}
+								OR fields->>'$.slug' = ${moduleIdOrSlug}) AS w
+				LEFT JOIN
+						(SELECT
+								crr.resourceOfId AS workshop_id,
+								crr.resourceId,
+								crr.position
+						 FROM ${contentResourceResource} crr) AS tlr ON w.id = tlr.workshop_id
+				LEFT JOIN ${contentResource} sections ON sections.id = tlr.resourceId AND sections.type = 'section'
+				LEFT JOIN
+						(SELECT
+								crr.resourceOfId AS section_id,
+								crr.resourceId AS resource_id,
+								crr.position AS position_in_section,
+								section_crr.position AS section_position
+						 FROM ${contentResourceResource} crr
+						 JOIN ${contentResourceResource} section_crr ON crr.resourceOfId = section_crr.resourceId) AS sr
+				ON sr.section_id = sections.id
+				JOIN ${contentResource} cr ON cr.id = COALESCE(sr.resource_id, tlr.resourceId)
+				LEFT JOIN ${resourceProgress} rp ON rp.resourceId = cr.id
+						AND rp.userId = ${user.id}
+				WHERE
+						cr.type IN ('lesson', 'exercise')
+
+    `);
+      const completedLessons = [];
+      let nextResource = null;
+      let completedLessonsCount = 0;
+      let totalLessonsCount = results.rows.length;
+      const parsedRows = z.array(ResultRowSchema).safeParse(results.rows);
+      if (!parsedRows.success) {
+        console.error("Error parsing rows", parsedRows.error);
         return {
           completedLessons: [],
           nextResource: null,
           percentCompleted: 0,
           completedLessonsCount: 0,
-          totalLessonsCount: parsedModuleResources.data.length
+          totalLessonsCount
         };
       }
-      const userProgress = await client.query.resourceProgress.findMany({
-        where: and(eq(resourceProgress.userId, parsedUser.data.id), isNotNull(resourceProgress.completedAt), inArray(resourceProgress.contentResourceId, parsedModuleResources.data.map((r) => r.resourceId))),
-        orderBy: asc(resourceProgress.completedAt)
-      });
-      const nextResourceId = moduleResources.find((r) => !userProgress.find((p) => p.contentResourceId === r.resourceId))?.resourceId;
-      const nextResource = await client.query.contentResource.findFirst({
-        where: eq(contentResource.id, nextResourceId)
-      });
-      const parsedNextResource = ContentResourceSchema.nullable().optional().default(null).parse(nextResource);
-      const parsedProgress = z.array(resourceProgressSchema).safeParse(userProgress);
-      if (!parsedProgress.success) {
-        console.error("Error parsing user progress", parsedProgress.error);
-        return {
-          completedLessons: [],
-          nextResource: null,
-          percentCompleted: 0,
-          completedLessonsCount: 0,
-          totalLessonsCount: parsedModuleResources.data.length
-        };
+      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 = Math.round(parsedProgress.data.length / parsedModuleResources.data.length * 100);
+      const percentCompleted = totalLessonsCount > 0 ? Math.ceil(completedLessonsCount / totalLessonsCount * 100) : 0;
       return {
-        completedLessons: parsedProgress.data,
-        nextResource: parsedNextResource,
+        completedLessons,
+        nextResource,
         percentCompleted,
-        completedLessonsCount: parsedProgress.data.length,
-        totalLessonsCount: parsedModuleResources.data.length
+        completedLessonsCount,
+        totalLessonsCount
       };
     },
     getLessonProgresses() {
@@ -9107,7 +9172,7 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
       });
       const parsed = merchantChargeSchema.safeParse(mCharge);
       if (!parsed.success) {
-        console.error("Error parsing merchantCharge", mCharge);
+        console.info("Error parsing merchantCharge", mCharge);
         return null;
       }
       return parsed.data;
@@ -9150,10 +9215,257 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
         where: eq(prices.productId, productId)
       }));
     },
-    async getProduct(productId) {
-      return productSchema.nullable().parse(await client.query.products.findFirst({
-        where: eq(products.id, productId)
+    async archiveProduct(productId) {
+      if (!paymentProvider)
+        throw new Error("Payment provider not found");
+      const product = await adapter.getProduct(productId);
+      if (!product) {
+        throw new Error(`Product not found for id (${productId})`);
+      }
+      if (!product.price) {
+        throw new Error(`Product has no price`);
+      }
+      await client.update(products).set({
+        status: 0,
+        name: `${product.name} (Archived)`
+      }).where(eq(products.id, productId));
+      await client.update(prices).set({
+        status: 0,
+        nickname: `${product.name} (Archived)`
+      }).where(eq(prices.productId, productId));
+      await client.update(merchantProduct).set({
+        status: 0
+      }).where(eq(merchantProduct.productId, productId));
+      await client.update(merchantPrice).set({
+        status: 0
+      }).where(eq(merchantPrice.priceId, product.price.id));
+      const currentMerchantProduct = merchantProductSchema.nullish().parse(await client.query.merchantProduct.findFirst({
+        where: eq(merchantProduct.productId, productId)
+      }));
+      if (!currentMerchantProduct || !currentMerchantProduct.identifier) {
+        throw new Error(`Merchant product not found for id (${productId})`);
+      }
+      await paymentProvider.updateProduct(currentMerchantProduct.identifier, {
+        active: false
+      });
+      const currentMerchantPrice = merchantPriceSchema.nullish().parse(await client.query.merchantPrice.findFirst({
+        where: and(eq(merchantPrice.priceId, product.price.id), eq(merchantPrice.status, 1))
+      }));
+      if (!currentMerchantPrice || !currentMerchantPrice.identifier) {
+        throw new Error(`Merchant price not found for id (${productId})`);
+      }
+      await paymentProvider.updatePrice(currentMerchantPrice.identifier, {
+        active: false
+      });
+      return adapter.getProduct(productId);
+    },
+    async updateProduct(input) {
+      if (!paymentProvider)
+        throw new Error("Payment provider not found");
+      const currentProduct = await adapter.getProduct(input.id);
+      if (!currentProduct) {
+        throw new Error(`Product not found`);
+      }
+      if (!currentProduct.price) {
+        throw new Error(`Product has no price`);
+      }
+      const merchantProduct2 = merchantProductSchema.nullish().parse(await client.query.merchantProduct.findFirst({
+        where: (merchantProduct3, { eq: eq2 }) => eq2(merchantProduct3.productId, input.id)
+      }));
+      if (!merchantProduct2 || !merchantProduct2.identifier) {
+        throw new Error(`Merchant product not found`);
+      }
+      const stripeProduct = await paymentProvider.getProduct(merchantProduct2.identifier);
+      const priceChanged = currentProduct.price.unitAmount.toString() !== input.price?.unitAmount.toString();
+      if (priceChanged) {
+        const currentMerchantPrice = merchantPriceSchema.nullish().parse(await client.query.merchantPrice.findFirst({
+          where: (merchantPrice2, { eq: eq2, and: and2 }) => and2(eq2(merchantPrice2.merchantProductId, merchantProduct2.id), eq2(merchantPrice2.status, 1))
+        }));
+        if (!currentMerchantPrice || !currentMerchantPrice.identifier) {
+          throw new Error(`Merchant price not found`);
+        }
+        const currentStripePrice = await paymentProvider.getPrice(currentMerchantPrice.identifier);
+        const newStripePrice = await paymentProvider.createPrice({
+          product: stripeProduct.id,
+          unit_amount: Math.floor(Number(input.price?.unitAmount || 0) * 100),
+          currency: "usd",
+          metadata: {
+            slug: input.fields.slug
+          },
+          active: true
+        });
+        await paymentProvider.updateProduct(stripeProduct.id, {
+          default_price: newStripePrice.id
+        });
+        const newMerchantPriceId = `mprice_${v4()}`;
+        await client.insert(merchantPrice).values({
+          id: newMerchantPriceId,
+          merchantProductId: merchantProduct2.id,
+          merchantAccountId: merchantProduct2.merchantAccountId,
+          priceId: currentProduct.price.id,
+          status: 1,
+          identifier: newStripePrice.id
+        });
+        if (currentMerchantPrice) {
+          await client.update(merchantPrice).set({
+            status: 0
+          }).where(eq(merchantPrice.id, currentMerchantPrice.id));
+        }
+        await client.update(prices).set({
+          unitAmount: Math.floor(Number(input.price?.unitAmount || 0)).toString(),
+          nickname: input.name
+        }).where(eq(prices.id, currentProduct.price.id));
+        if (currentStripePrice) {
+          await paymentProvider.updatePrice(currentStripePrice.id, {
+            active: false
+          });
+        }
+      }
+      await paymentProvider.updateProduct(stripeProduct.id, {
+        name: input.name,
+        active: true,
+        images: input.fields.image?.url ? [
+          input.fields.image.url
+        ] : void 0,
+        description: input.fields.description || "",
+        metadata: {
+          slug: input.fields.slug
+        }
+      });
+      const { image, ...fieldsNoImage } = input.fields;
+      await client.update(products).set({
+        name: input.name,
+        quantityAvailable: input.quantityAvailable,
+        status: 1,
+        fields: {
+          ...fieldsNoImage,
+          ...image?.url && {
+            image
+          }
+        }
+      }).where(eq(products.id, currentProduct.id));
+      return adapter.getProduct(currentProduct.id);
+    },
+    async createProduct(input) {
+      if (!paymentProvider)
+        throw new Error("Payment provider not found");
+      const merchantAccount2 = merchantAccountSchema.nullish().parse(await client.query.merchantAccount.findFirst({
+        where: (merchantAccount3, { eq: eq2 }) => eq2(merchantAccount3.label, "stripe")
+      }));
+      if (!merchantAccount2) {
+        throw new Error("Merchant account not found");
+      }
+      const hash = guid();
+      const newProductId = slugify(`product-${hash}`);
+      const newProduct = {
+        id: newProductId,
+        name: input.name,
+        status: 1,
+        type: "self-paced",
+        quantityAvailable: input.quantityAvailable,
+        fields: {
+          state: "draft",
+          visibility: "unlisted",
+          slug: slugify(`${input.name}-${hash}`)
+        }
+      };
+      await client.insert(products).values(newProduct);
+      const priceHash = guid();
+      const newPriceId = `price-${priceHash}`;
+      await client.insert(prices).values({
+        id: newPriceId,
+        productId: newProductId,
+        unitAmount: input.price.toString(),
+        status: 1
+      });
+      const product = await adapter.getProduct(newProductId);
+      const stripeProduct = await paymentProvider.createProduct({
+        name: input.name,
+        metadata: {
+          slug: product?.fields?.slug || null
+        }
+      });
+      const stripePrice = await paymentProvider.createPrice({
+        product: stripeProduct.id,
+        unit_amount: Math.floor(Number(input.price) * 100),
+        currency: "usd",
+        nickname: input.name,
+        metadata: {
+          slug: product?.fields?.slug || null
+        }
+      });
+      const newMerchantProductId = `mproduct_${v4()}`;
+      await client.insert(merchantProduct).values({
+        id: newMerchantProductId,
+        merchantAccountId: merchantAccount2.id,
+        productId: newProductId,
+        identifier: stripeProduct.id,
+        status: 1
+      });
+      const newMerchantPriceId = `mprice_${v4()}`;
+      await client.insert(merchantPrice).values({
+        id: newMerchantPriceId,
+        merchantAccountId: merchantAccount2.id,
+        merchantProductId: newMerchantProductId,
+        priceId: newPriceId,
+        identifier: stripePrice.id,
+        status: 1
+      });
+      return product;
+    },
+    async getProduct(productSlugOrId, withResources = true) {
+      if (!productSlugOrId) {
+        return null;
+      }
+      try {
+        const productData = await client.query.products.findFirst({
+          where: and(or(eq(sql`JSON_EXTRACT (${products.fields}, "$.slug")`, `${productSlugOrId}`), eq(products.id, productSlugOrId))),
+          with: {
+            price: true,
+            ...withResources && {
+              resources: {
+                with: {
+                  resource: {
+                    with: {
+                      resources: true
+                    }
+                  }
+                }
+              }
+            }
+          }
+        });
+        const parsedProduct = productSchema.safeParse(productData);
+        if (!parsedProduct.success) {
+          console.error("Error parsing product", JSON.stringify(parsedProduct.error), JSON.stringify(productData));
+          return null;
+        }
+        return parsedProduct.data;
+      } catch (e) {
+        console.log("getProduct error", e);
+        return null;
+      }
+    },
+    async getProductResources(productId) {
+      const contentResourceProductsForProduct = z.array(ContentResourceProductSchema).nullable().parse(await client.query.contentResourceProduct.findMany({
+        where: eq(contentResourceProduct.productId, productId)
       }));
+      if (!contentResourceProductsForProduct) {
+        return null;
+      } else {
+        const contentResources = z.array(ContentResourceSchema).parse(await client.query.contentResource.findMany({
+          where: inArray(contentResource.id, contentResourceProductsForProduct.map((crp) => crp.resourceId))
+        }));
+        return contentResources;
+      }
+    },
+    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({
@@ -9178,7 +9490,7 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
         where: eq(merchantCharge.identifier, stripeChargeId)
       }) || null);
       if (!chargeForPurchase) {
-        logger.error(new Error("No charge found for purchase"));
+        logger.error(new Error(`No charge found for purchase: Stripe Charge ID: ${stripeChargeId}`));
         return null;
       }
       const purchase = purchaseSchema.safeParse(await client.query.purchases.findFirst({
@@ -9313,6 +9625,33 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
         purchase: parsedPurchase.data
       };
     },
+    async getUserWithPurchasersByEmail(email) {
+      const user = await client.query.users.findFirst({
+        where: eq(users.email, email.trim().toLowerCase()),
+        with: {
+          // merchantCustomer: true,
+          roles: {
+            with: {
+              role: true
+            }
+          },
+          purchases: {
+            with: {
+              bulkCoupon: true,
+              merchantCharge: true,
+              product: {
+                columns: {
+                  id: true,
+                  name: true,
+                  key: true
+                }
+              }
+            }
+          }
+        }
+      });
+      return user;
+    },
     async getUserById(userId) {
       const user = await client.query.users.findFirst({
         where: eq(users.id, userId),
@@ -9360,24 +9699,24 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
         throw new Error("No lessonId provided");
       }
       let lessonProgress = await client.query.resourceProgress.findFirst({
-        where: and(eq(resourceProgress.userId, options.userId), eq(resourceProgress.contentResourceId, options.lessonId))
+        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(eq(resourceProgress.contentResourceId, options.lessonId));
+        }).where(eq(resourceProgress.resourceId, options.lessonId));
       } else {
         await client.insert(resourceProgress).values({
           userId: options.userId,
-          contentResourceId: options.lessonId,
+          resourceId: options.lessonId,
           completedAt: now,
           updatedAt: now
         });
       }
       lessonProgress = await client.query.resourceProgress.findFirst({
-        where: and(eq(resourceProgress.userId, options.userId), eq(resourceProgress.contentResourceId, options.lessonId))
+        where: and(eq(resourceProgress.userId, options.userId), eq(resourceProgress.resourceId, options.lessonId))
       });
       const parsedLessonProgress = resourceProgressSchema.safeParse(lessonProgress);
       if (!parsedLessonProgress.success) {
@@ -9389,8 +9728,40 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
     transferPurchasesToNewUser(options) {
       throw new Error("Method not implemented.");
     },
-    updatePurchaseStatusForCharge(chargeId, status) {
-      throw new Error("updatePurchaseStatusForCharge Method not implemented.");
+    async updatePurchaseStatusForCharge(chargeId, status) {
+      try {
+        console.log("updatePurchaseStatusForCharge", {
+          chargeId,
+          status
+        });
+        const merchantChargeForPurchase = await client.query.merchantCharge.findFirst({
+          where: or(eq(merchantCharge.identifier, chargeId), eq(merchantCharge.id, chargeId))
+        });
+        console.log("merchantChargeForPurchase", {
+          merchantChargeForPurchase
+        });
+        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) {
+        console.log("error updating purchase status", e);
+        throw e;
+      }
     },
     async updatePurchaseUserTransferTransferState(options) {
       await client.update(purchaseUserTransfer).set({
@@ -9427,6 +9798,18 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
       }
       return parsedResourceJoin.data;
     },
+    async removeResourceFromResource(options) {
+      const { childResourceId, parentResourceId } = options;
+      const resourceJoin = await client.query.contentResourceResource.findFirst({
+        where: and(eq(contentResourceResource.resourceOfId, parentResourceId), eq(contentResourceResource.resourceId, childResourceId))
+      });
+      const parsedResourceJoin = ContentResourceResourceSchema.safeParse(resourceJoin);
+      if (!parsedResourceJoin.success) {
+        return null;
+      }
+      await client.delete(contentResourceResource).where(and(eq(contentResourceResource.resourceOfId, parentResourceId), eq(contentResourceResource.resourceId, childResourceId)));
+      return parsedResourceJoin.data.resource;
+    },
     async updateContentResourceFields(options) {
       if (!options.id) {
         throw new Error("No content resource id.");
@@ -9537,7 +9920,15 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
                 with: {
                   resources: {
                     with: {
-                      resource: true
+                      resource: {
+                        with: {
+                          resources: {
+                            with: {
+                              resource: true
+                            }
+                          }
+                        }
+                      }
                     },
                     orderBy: asc(contentResourceResource.position)
                   }
@@ -9603,7 +9994,7 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
       if (!dbAccount) {
         return null;
       }
-      return dbAccount.user;
+      return dbAccount.User;
     },
     async deleteSession(sessionToken) {
       const session = await client.select().from(sessions).where(eq(sessions.sessionToken, sessionToken)).then((res) => res[0]) ?? null;
@@ -9651,8 +10042,9 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
 __name(mySqlDrizzleAdapter, "mySqlDrizzleAdapter");
 
 export {
+  guid,
   getCourseBuilderSchema,
   createTables,
   mySqlDrizzleAdapter
 };
-//# sourceMappingURL=chunk-A26D3TCA.js.map
+//# sourceMappingURL=chunk-VUS77FG3.js.map