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

package/dist/chunk-TNWNW666.js

@@ -0,0 +1,133 @@
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/ports/identity.ts
+import { and, eq } from "drizzle-orm";
+import { v4 } from "uuid";
+import { userSchema } from "@coursebuilder/core/schemas";
+import { logger as baseLogger } from "@coursebuilder/utils/logger";
+var logger = baseLogger;
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+__name(toError, "toError");
+function createIdentityPort({ client, tables }) {
+  const { accounts, users, verificationTokens } = tables;
+  const getUser = /* @__PURE__ */ __name(async (data) => await client.select().from(users).where(eq(users.id, data)).then((res) => res[0]) ?? null, "getUser");
+  const getUserByEmail = /* @__PURE__ */ __name(async (data) => await client.select().from(users).where(eq(users.email, data)).then((res) => res[0]) ?? null, "getUserByEmail");
+  const createUser = /* @__PURE__ */ __name(async (data) => {
+    const id = crypto.randomUUID();
+    try {
+      await client.insert(users).values({
+        ...data,
+        id
+      });
+      const user = await getUser(id);
+      if (!user)
+        throw new Error("Failed to get user");
+      return user;
+    } catch (error) {
+      logger.error(toError(error), {
+        email: data.email,
+        event: "adapter.user.create.failed",
+        userId: id
+      });
+      throw error;
+    }
+  }, "createUser");
+  return {
+    createUser,
+    getUser,
+    getUserByEmail,
+    updateUser: async (data) => {
+      if (!data.id)
+        throw new Error("No user id.");
+      await client.update(users).set(data).where(eq(users.id, data.id));
+      return await client.select().from(users).where(eq(users.id, data.id)).then((res) => res[0]);
+    },
+    linkAccount: async (rawAccount) => {
+      await client.insert(accounts).values(rawAccount);
+    },
+    getUserByAccount: async (account) => {
+      const dbAccount = await client.select().from(accounts).where(and(eq(accounts.providerAccountId, account.providerAccountId), eq(accounts.provider, account.provider))).leftJoin(users, eq(accounts.userId, users.id)).then((res) => res[0]) ?? null;
+      return dbAccount?.User ?? null;
+    },
+    unlinkAccount: async (account) => {
+      await client.delete(accounts).where(and(eq(accounts.providerAccountId, account.providerAccountId), eq(accounts.provider, account.provider)));
+      return void 0;
+    },
+    createVerificationToken: async (token) => {
+      await client.insert(verificationTokens).values(token);
+      return await client.select().from(verificationTokens).where(eq(verificationTokens.identifier, token.identifier)).then((res) => res[0]);
+    },
+    findOrCreateUser: async (email, name) => {
+      const user = await getUserByEmail(email);
+      if (!user) {
+        const newUser = await createUser({
+          id: `u_${v4()}`,
+          email,
+          name,
+          emailVerified: null
+        });
+        logger.info("adapter.user.created", {
+          email,
+          userId: newUser.id
+        });
+        return {
+          user: newUser,
+          isNewUser: true
+        };
+      }
+      return {
+        user,
+        isNewUser: false
+      };
+    },
+    getUserWithPurchasersByEmail: async (email) => client.query.users.findFirst({
+      where: eq(users.email, email.trim().toLowerCase()),
+      with: {
+        roles: {
+          with: {
+            role: true
+          }
+        },
+        purchases: {
+          with: {
+            bulkCoupon: true,
+            merchantCharge: true,
+            product: {
+              columns: {
+                id: true,
+                name: true,
+                key: true
+              }
+            }
+          }
+        }
+      }
+    }),
+    getUserById: async (userId) => {
+      const user = await client.query.users.findFirst({
+        where: eq(users.id, userId),
+        with: {
+          roles: {
+            with: {
+              role: true
+            }
+          }
+        }
+      }).then(async (res) => res ? {
+        ...res,
+        roles: res.roles.map((r) => r.role)
+      } : void 0);
+      return userSchema.nullable().parse(user ?? null);
+    }
+  };
+}
+__name(createIdentityPort, "createIdentityPort");
+
+export {
+  createIdentityPort
+};
+//# sourceMappingURL=chunk-TNWNW666.js.map

package/dist/chunk-VBEXYQ6L.js

@@ -0,0 +1,156 @@
+import {
+  guid,
+  normalizeExpirationDate
+} from "./chunk-6XQ6C3IX.js";
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/workflows/create-event.ts
+import slugify from "@sindresorhus/slugify";
+import { ContentResourceSchema } from "@coursebuilder/core/schemas/content-resource-schema";
+import { logger as baseLogger } from "@coursebuilder/utils/logger";
+var logger = baseLogger;
+function createEventWorkflow({ client, tables }, operations) {
+  const { contentResource, contentResourceTag } = tables;
+  return {
+    async createEvent(input, userId) {
+      const hash = guid();
+      const newEventId = slugify(`${input.type}~${hash}`);
+      const newEvent = {
+        id: newEventId,
+        type: "event",
+        fields: {
+          title: input.fields.title,
+          state: "draft",
+          visibility: "public",
+          slug: slugify(`${input.fields.title}~${hash}`),
+          description: input.fields.description,
+          startsAt: input.fields.startsAt,
+          endsAt: input.fields.endsAt
+        },
+        createdById: userId
+      };
+      await client.insert(contentResource).values(newEvent);
+      const event = await operations.getEvent(newEventId, {
+        withResources: true,
+        withTags: true,
+        withProducts: true,
+        withPricing: true
+      });
+      const parsedEvent = ContentResourceSchema.safeParse(event);
+      if (!parsedEvent.success) {
+        logger.error(new Error("Error parsing event resource"));
+        throw new Error("Error parsing event resource");
+      }
+      if (input.fields.price && input.fields.price > 0) {
+        try {
+          const product = await operations.createProduct({
+            name: input.fields.title,
+            price: input.fields.price,
+            quantityAvailable: input.fields.quantity ?? -1,
+            type: "live",
+            state: "published",
+            visibility: "public"
+          });
+          if (product) {
+            const resourceProduct = await operations.addResourceToProduct({
+              resource: parsedEvent.data,
+              productId: product.id,
+              userId
+            });
+            if (!resourceProduct) {
+              logger.error(new Error("Failed to add resource to product"));
+              logger.debug("event.addResourceToProduct.failed", {
+                eventId: newEventId,
+                productId: product.id,
+                userId
+              });
+            } else {
+              logger.debug("event.addResourceToProduct.success", {
+                eventId: newEventId,
+                productId: product.id,
+                userId
+              });
+            }
+            if (input.coupon?.enabled && input.coupon.percentageDiscount && input.coupon.expires) {
+              try {
+                const finalExpires = normalizeExpirationDate(input.coupon.expires);
+                const couponInput = {
+                  quantity: "1",
+                  maxUses: -1,
+                  expires: finalExpires || null,
+                  restrictedToProductId: product.id,
+                  percentageDiscount: input.coupon.percentageDiscount,
+                  status: 1,
+                  default: true,
+                  fields: {
+                    bypassSoldOut: false
+                  }
+                };
+                await operations.createCoupon(couponInput);
+                logger.debug("event.create.coupon.success", {
+                  eventId: newEventId,
+                  productId: product.id,
+                  userId,
+                  percentageDiscount: input.coupon.percentageDiscount
+                });
+              } catch (couponError) {
+                logger.error(new Error(`Failed to create coupon for event: ${couponError}`));
+                logger.debug("event.create.coupon.failed", {
+                  eventId: newEventId,
+                  productId: product.id,
+                  userId
+                });
+              }
+            }
+          } else {
+            logger.error(new Error("Failed to create product"));
+            logger.debug("event.create.product.failed", {
+              eventId: newEventId,
+              userId,
+              price: input.fields.price
+            });
+          }
+        } catch (error) {
+          logger.error(new Error(`Error creating and associating product: ${error}`));
+          logger.debug("event.create.product.failed", {
+            eventId: newEventId,
+            userId,
+            price: input.fields.price
+          });
+        }
+      }
+      if (input.fields.tagIds) {
+        try {
+          await client.insert(contentResourceTag).values(input.fields.tagIds.map((tag) => ({
+            contentResourceId: newEventId,
+            tagId: tag.id,
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date(),
+            position: 0
+          })));
+          logger.debug("event.create.tags.success", {
+            eventId: newEventId,
+            userId,
+            tagIds: input.fields.tagIds
+          });
+        } catch (error) {
+          logger.error(new Error(`Error associating tags with event: ${error}`));
+          logger.debug("event.create.tags.failed", {
+            eventId: newEventId,
+            userId,
+            tagIds: input.fields.tagIds
+          });
+        }
+      }
+      return parsedEvent.data;
+    }
+  };
+}
+__name(createEventWorkflow, "createEventWorkflow");
+
+export {
+  createEventWorkflow
+};
+//# sourceMappingURL=chunk-VBEXYQ6L.js.map

package/dist/chunk-W3ILNMLD.js

@@ -0,0 +1,265 @@
+import {
+  external_exports
+} from "./chunk-QKOSV34V.js";
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/ports/progress.ts
+import { and, eq, inArray, or, sql } from "drizzle-orm";
+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 = external_exports.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 = external_exports.object({
+        resource_id: external_exports.string(),
+        resource_type: external_exports.enum([
+          "lesson",
+          "exercise",
+          "post"
+        ]),
+        resource_slug: external_exports.string().nullable(),
+        completed_at: external_exports.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 = external_exports.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 = external_exports.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-W3ILNMLD.js.map

package/dist/chunk-WJ2ZUXL3.js

@@ -0,0 +1,71 @@
+import {
+  external_exports
+} from "./chunk-QKOSV34V.js";
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/ports/entitlement.ts
+import { and, asc, eq, gte, isNull, or, sql } from "drizzle-orm";
+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 = external_exports.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-WJ2ZUXL3.js.map

package/dist/{chunk-PJORQUQP.js → chunk-WUMDFFN3.js}

@@ -1,6 +1,6 @@
 import {
   getUsersSchema
-} from "./chunk-PNPTKVJ4.js";
+} from "./chunk-XUBZKYH6.js";
 import {
   __name
 } from "./chunk-2X5XVNDN.js";
@@ -55,4 +55,4 @@ export {
   getDeviceAccessTokenSchema,
   getDeviceAccessTokenRelationsSchema
 };
-//# sourceMappingURL=chunk-PJORQUQP.js.map
+//# sourceMappingURL=chunk-WUMDFFN3.js.map

package/dist/{chunk-2AW5KYAK.js → chunk-X7DRYXB7.js}

@@ -2,7 +2,7 @@ import {
   getOrganizationMembershipsSchema,
   getOrganizationsSchema,
   getUsersSchema
-} from "./chunk-PNPTKVJ4.js";
+} from "./chunk-XUBZKYH6.js";
 import {
   __name
 } from "./chunk-2X5XVNDN.js";
@@ -98,4 +98,4 @@ export {
   getEntitlementsSchema,
   getEntitlementRelationsSchema
 };
-//# sourceMappingURL=chunk-2AW5KYAK.js.map
+//# sourceMappingURL=chunk-X7DRYXB7.js.map