@coursebuilder/adapter-drizzle 0.5.0 → 0.5.2

package/dist/{chunk-Z245DYMP.js → chunk-ZYQYJNLK.js}

@@ -7,30 +7,30 @@ import {
 import {
   getPurchaseUserTransferRelationsSchema,
   getPurchaseUserTransferSchema
-} from "./chunk-CQNKTFXE.js";
+} from "./chunk-XJXCDN7B.js";
 import {
   getUpgradableProductsRelationsSchema,
   getUpgradableProductsSchema
-} from "./chunk-BM5UKWXI.js";
+} from "./chunk-27UC2HEP.js";
 import {
   getRolePermissionsRelationsSchema,
   getRolePermissionsSchema
-} from "./chunk-O6JECJRY.js";
+} from "./chunk-QQA7STVO.js";
 import {
   getSessionRelationsSchema,
   getSessionsSchema
-} from "./chunk-TBM3AK3P.js";
+} from "./chunk-EFVZ7IN4.js";
 import {
   getVerificationTokensSchema
 } from "./chunk-LERR6HQ3.js";
 import {
   getDeviceAccessTokenRelationsSchema,
   getDeviceAccessTokenSchema
-} from "./chunk-QTGVGIRO.js";
+} from "./chunk-6SLQW6OM.js";
 import {
   getDeviceVerificationRelationsSchema,
   getDeviceVerificationSchema
-} from "./chunk-JZQ666KH.js";
+} from "./chunk-YMFPIZMO.js";
 import {
   getAccountsRelationsSchema,
   getAccountsSchema,
@@ -46,6 +46,10 @@ import {
   getContentResourceResourceRelationsSchema,
   getContentResourceResourceSchema,
   getContentResourceSchema,
+  getContentResourceTagRelationsSchema,
+  getContentResourceTagSchema,
+  getContentResourceVersionRelationsSchema,
+  getContentResourceVersionSchema,
   getCouponRelationsSchema,
   getCouponSchema,
   getPriceSchema,
@@ -55,6 +59,10 @@ import {
   getPurchaseSchema,
   getRolesRelationsSchema,
   getRolesSchema,
+  getTagRelationsSchema,
+  getTagSchema,
+  getTagTagRelationsSchema,
+  getTagTagSchema,
   getUserPermissionsRelationsSchema,
   getUserPermissionsSchema,
   getUserPrefsRelationsSchema,
@@ -63,7 +71,7 @@ import {
   getUserRolesSchema,
   getUsersRelationsSchema,
   getUsersSchema
-} from "./chunk-FRA4ZCRA.js";
+} from "./chunk-JW2PFVLO.js";
 import {
   getContributionTypesRelationsSchema,
   getContributionTypesSchema
@@ -105,9 +113,11 @@ import {
 } 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
@@ -8123,6 +8133,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),
@@ -8157,25 +8190,26 @@ var priceSchema = z2.object({
   fields: z2.record(z2.any()).default({})
 });
 
-// ../core/dist/chunk-YYIPQN6H.js
+// ../core/dist/chunk-6BXXN6IV.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({
   id: z2.string(),
   type: z2.string(),
   createdById: z2.string(),
+  currentVersionId: z2.string().nullish(),
   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({
@@ -8183,9 +8217,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()
 });
@@ -8201,7 +8235,7 @@ var ResourceVisibilitySchema = z2.union([
   z2.literal("unlisted")
 ]);
 
-// ../core/dist/chunk-DGMGNBW7.js
+// ../core/dist/chunk-LVVTCZ7P.js
 var productSchema = z2.object({
   id: z2.string().max(191),
   name: z2.string().max(191),
@@ -8212,10 +8246,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()
@@ -8233,14 +8267,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(),
@@ -8257,11 +8296,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-ACXDXYNY.js
 var purchaseSchema = z2.object({
   id: z2.string().max(191),
   userId: z2.string().max(191).optional().nullable(),
@@ -8310,18 +8350,15 @@ var purchaseUserTransferSchema = z2.object({
   completedAt: z2.date().nullable()
 });
 
-// ../core/dist/chunk-K6G2HAJT.js
+// ../core/dist/chunk-6BTTEQD2.js
 var resourceProgressSchema = z2.object({
   userId: z2.string().max(191),
   resourceId: z2.string().max(191).optional().nullable(),
-  fields: z2.record(z2.any()).default({}),
-  completedAt: z2.date().nullable(),
-  updatedAt: z2.date().nullable(),
-  createdAt: z2.date().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)
@@ -8338,29 +8375,6 @@ var upgradableProductSchema = z2.object({
   deletedAt: z2.date().nullable()
 });
 
-// ../core/dist/chunk-5QZXOTEH.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",
-    "deleted"
-  ])
-});
-
 // ../core/dist/chunk-EDDT2FFU.js
 var merchantCustomerSchema = z2.object({
   id: z2.string().max(191),
@@ -8556,6 +8570,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),
@@ -8599,9 +8614,13 @@ function getCourseBuilderSchema(mysqlTable) {
     contentContributions: getContentContributionsSchema(mysqlTable),
     contentContributionRelations: getContentContributionRelationsSchema(mysqlTable),
     contentResource: getContentResourceSchema(mysqlTable),
+    contentResourceVersion: getContentResourceVersionSchema(mysqlTable),
+    contentResourceVersionRelations: getContentResourceVersionRelationsSchema(mysqlTable),
     contentResourceRelations: getContentResourceRelationsSchema(mysqlTable),
     contentResourceResource: getContentResourceResourceSchema(mysqlTable),
     contentResourceResourceRelations: getContentResourceResourceRelationsSchema(mysqlTable),
+    contentResourceTag: getContentResourceTagSchema(mysqlTable),
+    contentResourceTagRelations: getContentResourceTagRelationsSchema(mysqlTable),
     contributionTypes: getContributionTypesSchema(mysqlTable),
     contributionTypesRelations: getContributionTypesRelationsSchema(mysqlTable),
     resourceProgress: getResourceProgressSchema(mysqlTable),
@@ -8616,6 +8635,10 @@ function getCourseBuilderSchema(mysqlTable) {
     deviceVerificationRelations: getDeviceVerificationRelationsSchema(mysqlTable),
     deviceAccessToken: getDeviceAccessTokenSchema(mysqlTable),
     deviceAccessTokenRelations: getDeviceAccessTokenRelationsSchema(mysqlTable),
+    tag: getTagSchema(mysqlTable),
+    tagRelations: getTagRelationsSchema(mysqlTable),
+    tagTag: getTagTagSchema(mysqlTable),
+    tagTagRelations: getTagTagRelationsSchema(mysqlTable),
     userPrefs: getUserPrefsSchema(mysqlTable),
     userPrefsRelations: getUserPrefsRelationsSchema(mysqlTable)
   };
@@ -8625,8 +8648,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, comments } = 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) {
@@ -8638,7 +8661,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}`);
@@ -8648,8 +8671,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,
@@ -8715,7 +8748,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) {
@@ -8749,7 +8782,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))
         });
       }
@@ -8971,18 +9004,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,
@@ -8990,12 +9036,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;
@@ -9037,109 +9086,65 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
       return parsed.data;
     },
     async getModuleProgressForUser(userIdOrEmail, moduleIdOrSlug) {
-      const ALLOWED_MODULE_RESOURCE_TYPES = [
-        "lesson",
-        "exercise",
-        "solution"
-      ];
-      const COUNTABLE_MODULE_RESOURCE_TYPES = [
-        "lesson",
-        "exercise"
-      ];
-      const module = await client.query.contentResource.findFirst({
-        where: or(eq(contentResource.id, moduleIdOrSlug), eq(sql`JSON_EXTRACT (${contentResource.fields}, "$.slug")`, moduleIdOrSlug)),
-        with: {
-          resources: {
-            with: {
-              resource: {
-                with: {
-                  resources: {
-                    with: {
-                      resource: {
-                        with: {
-                          resources: {
-                            with: {
-                              resource: true
-                            }
-                          }
-                        }
-                      }
-                    },
-                    orderBy: asc(contentResourceResource.position)
-                  }
-                }
-              }
-            },
-            orderBy: asc(contentResourceResource.position)
-          }
-        }
-      });
-      const parsedModule = ContentResourceSchema.parse(module);
-      function flattenResources(resources) {
-        const result = [];
-        function recurse(resources2) {
-          for (const nestedResource of resources2) {
-            const resource = nestedResource.resource;
-            result.push(resource);
-            if (resource.resources) {
-              recurse(resource.resources);
-            }
-          }
-        }
-        __name(recurse, "recurse");
-        recurse(resources);
-        return result;
-      }
-      __name(flattenResources, "flattenResources");
-      const allResources = parsedModule?.resources && flattenResources(parsedModule.resources);
-      const filteredResources = allResources?.filter((resource) => {
-        return ALLOWED_MODULE_RESOURCE_TYPES.includes(resource.type);
-      });
-      const parsedResources = z.array(ContentResourceSchema).safeParse(filteredResources);
-      if (!parsedResources.success) {
-        console.error("Error parsing module resources", parsedResources.error);
-        return {
-          completedLessons: [],
-          nextResource: null,
-          percentCompleted: 0,
-          completedLessonsCount: 0,
-          totalLessonsCount: 0
-        };
-      }
-      const progressResources = parsedResources.data.filter((r) => {
-        return COUNTABLE_MODULE_RESOURCE_TYPES.includes(r.type);
-      });
-      const totalLessonsCount = progressResources.length;
       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
-        };
+        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,
@@ -9148,34 +9153,30 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
           totalLessonsCount
         };
       }
-      const userProgress = await client.query.resourceProgress.findMany({
-        where: and(eq(resourceProgress.userId, parsedUser.data.id), isNotNull(resourceProgress.completedAt), inArray(resourceProgress.resourceId, progressResources.map((r) => r.id))),
-        orderBy: asc(resourceProgress.completedAt)
-      });
-      const nextResourceId = parsedResources.data.filter((r) => {
-        return COUNTABLE_MODULE_RESOURCE_TYPES.includes(r.type);
-      }).find((r) => !userProgress.find((p) => p.resourceId === r.id))?.id;
-      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
-        };
+      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 / parsedResources.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,
+        completedLessonsCount,
         totalLessonsCount
       };
     },
@@ -9188,7 +9189,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;
@@ -9231,10 +9232,249 @@ 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({
@@ -9267,7 +9507,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({
@@ -9402,6 +9642,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),
@@ -9475,11 +9742,102 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
       }
       return parsedLessonProgress.data;
     },
+    transferPurchaseToUser: async (options) => {
+      const { purchaseId, targetUserId, sourceUserId } = options;
+      const transferId = `put_${v4()}`;
+      let purchase = await adapter.getPurchase(purchaseId);
+      if (!purchase)
+        throw new Error("No purchase found");
+      if (purchase.userId !== sourceUserId)
+        throw new Error("Invalid source user");
+      await client.transaction(async (trx) => {
+        if (!purchase)
+          throw new Error("No purchase found");
+        await trx.update(purchaseTable).set({
+          userId: targetUserId
+        }).where(eq(purchaseTable.id, purchase.id));
+        await trx.insert(purchaseUserTransfer).values({
+          id: transferId,
+          purchaseId: purchase.id,
+          sourceUserId,
+          targetUserId,
+          transferState: "COMPLETED",
+          completedAt: /* @__PURE__ */ new Date()
+        });
+        purchase = await adapter.getPurchase(purchaseId);
+        if (!purchase)
+          throw new Error("No purchase found");
+        if (paymentProvider && purchase.merchantChargeId) {
+          await trx.update(merchantCharge).set({
+            userId: targetUserId
+          }).where(eq(merchantCharge.id, purchase.merchantChargeId));
+          const updatedMerchantCharge = await adapter.getMerchantCharge(purchase.merchantChargeId);
+          if (!updatedMerchantCharge)
+            throw new Error("No merchant charge found");
+          await trx.update(merchantCustomer).set({
+            userId: targetUserId
+          }).where(eq(merchantCustomer.id, updatedMerchantCharge.merchantCustomerId));
+          const updatedMerchantCustomer = merchantCustomerSchema.parse(await client.query.merchantCustomer.findFirst({
+            where: eq(merchantCustomer.id, updatedMerchantCharge.merchantCustomerId)
+          }));
+          const targetUser = userSchema.parse(await client.query.users.findFirst({
+            where: eq(users.id, targetUserId)
+          }));
+          const sourceUser = userSchema.parse(await client.query.users.findFirst({
+            where: eq(users.id, sourceUserId)
+          }));
+          await paymentProvider.updateCustomer(updatedMerchantCustomer.identifier, {
+            email: targetUser.email,
+            name: targetUser.name || sourceUser.name || "",
+            metadata: {
+              transferId,
+              transferredFrom: sourceUser.email,
+              transferredOn: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          });
+        }
+      });
+      return await adapter.getPurchaseUserTransferById({
+        id: transferId
+      });
+    },
     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({
@@ -9516,6 +9874,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.");
@@ -9748,8 +10118,9 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
 __name(mySqlDrizzleAdapter, "mySqlDrizzleAdapter");
 
 export {
+  guid,
   getCourseBuilderSchema,
   createTables,
   mySqlDrizzleAdapter
 };
-//# sourceMappingURL=chunk-Z245DYMP.js.map
+//# sourceMappingURL=chunk-ZYQYJNLK.js.map