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

package/dist/{chunk-KIQLUFJX.js → chunk-2GW3BJE2.js}

@@ -1,7 +1,7 @@
 import {
   getContentResourceSchema,
   getUsersSchema
-} from "./chunk-PNPTKVJ4.js";
+} from "./chunk-XUBZKYH6.js";
 import {
   __name
 } from "./chunk-2X5XVNDN.js";
@@ -98,4 +98,4 @@ export {
   getQuestionResponseSchema,
   getQuestionResponseRelationsSchema
 };
-//# sourceMappingURL=chunk-KIQLUFJX.js.map
+//# sourceMappingURL=chunk-2GW3BJE2.js.map

package/dist/{chunk-M3WM5Q7W.js → chunk-33ZN7FN7.js}

@@ -1,6 +1,6 @@
 import {
   getUsersSchema
-} from "./chunk-PNPTKVJ4.js";
+} from "./chunk-XUBZKYH6.js";
 import {
   __name
 } from "./chunk-2X5XVNDN.js";
@@ -85,4 +85,4 @@ export {
   getPersonalAccessTokenSchema,
   getPersonalAccessTokenRelationsSchema
 };
-//# sourceMappingURL=chunk-M3WM5Q7W.js.map
+//# sourceMappingURL=chunk-33ZN7FN7.js.map

package/dist/chunk-4VZJQAPV.js

@@ -0,0 +1,74 @@
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/workflows/transfer-purchase-to-user.ts
+import { eq } from "drizzle-orm";
+import { v4 } from "uuid";
+import { merchantChargeSchema, userSchema } from "@coursebuilder/core/schemas";
+import { merchantCustomerSchema } from "@coursebuilder/core/schemas/merchant-customer-schema";
+function createTransferPurchaseToUserWorkflow({ client, tables }, paymentProvider, operations) {
+  const { users, purchases: purchaseTable, purchaseUserTransfer, merchantCharge, merchantCustomer } = tables;
+  return {
+    transferPurchaseToUser: async (options) => {
+      const { purchaseId, targetUserId, sourceUserId } = options;
+      const transferId = `put_${v4()}`;
+      await client.transaction(async (trx) => {
+        const purchase = await trx.select().from(purchaseTable).where(eq(purchaseTable.id, purchaseId)).for("update").then((rows) => rows[0]);
+        if (!purchase)
+          throw new Error("No purchase found");
+        if (purchase.userId !== sourceUserId)
+          throw new Error("Invalid source user");
+        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()
+        });
+        if (paymentProvider && purchase.merchantChargeId) {
+          await trx.update(merchantCharge).set({
+            userId: targetUserId
+          }).where(eq(merchantCharge.id, purchase.merchantChargeId));
+          const updatedMerchantCharge = merchantChargeSchema.parse(await trx.query.merchantCharge.findFirst({
+            where: eq(merchantCharge.id, purchase.merchantChargeId)
+          }));
+          await trx.update(merchantCustomer).set({
+            userId: targetUserId
+          }).where(eq(merchantCustomer.id, updatedMerchantCharge.merchantCustomerId));
+          const updatedMerchantCustomer = merchantCustomerSchema.parse(await trx.query.merchantCustomer.findFirst({
+            where: eq(merchantCustomer.id, updatedMerchantCharge.merchantCustomerId)
+          }));
+          const targetUser = userSchema.parse(await trx.query.users.findFirst({
+            where: eq(users.id, targetUserId)
+          }));
+          const sourceUser = userSchema.parse(await trx.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 operations.getPurchaseUserTransferById({
+        id: transferId
+      });
+    }
+  };
+}
+__name(createTransferPurchaseToUserWorkflow, "createTransferPurchaseToUserWorkflow");
+
+export {
+  createTransferPurchaseToUserWorkflow
+};
+//# sourceMappingURL=chunk-4VZJQAPV.js.map

package/dist/chunk-5FLS4ZBX.js

@@ -0,0 +1,109 @@
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/workflows/redeem-full-price-coupon.ts
+import { and, eq } from "drizzle-orm";
+import { v4 } from "uuid";
+import { logger } from "@coursebuilder/utils/logger";
+import { validateCoupon } from "@coursebuilder/commerce/validate-coupon";
+var normalizeLearnerEmail = /* @__PURE__ */ __name((email) => email.trim().toLowerCase().replace(/\s+/g, "+"), "normalizeLearnerEmail");
+function createRedeemFullPriceCouponWorkflow({ client, tables }, operations) {
+  const { purchases: purchaseTable } = tables;
+  return {
+    async redeemFullPriceCoupon(options) {
+      const { email: baseEmail, couponId, productIds, currentUserId, redeemingProductId } = options;
+      const email = normalizeLearnerEmail(String(baseEmail));
+      const coupon = await operations.getCouponWithBulkPurchases(couponId);
+      const productId = coupon && coupon.restrictedToProductId || redeemingProductId;
+      if (!productId)
+        throw new Error(`unable-to-find-any-product-id`);
+      const couponValidation = validateCoupon(coupon, productIds);
+      if (coupon && couponValidation.isRedeemable) {
+        const bulkCouponRedemption = Boolean(coupon.maxUses > 1);
+        const { user } = await operations.findOrCreateUser(email);
+        if (!user)
+          throw new Error(`unable-to-create-user-${email}`);
+        const currentUser = currentUserId ? await operations.getUserById(currentUserId) : null;
+        const redeemingForCurrentUser = currentUser?.id === user.id;
+        if (bulkCouponRedemption) {
+          const existingValidRedemption = await client.query.purchases.findFirst({
+            where: and(eq(purchaseTable.redeemedBulkCouponId, coupon.id), eq(purchaseTable.userId, user.id), eq(purchaseTable.status, "Valid"))
+          });
+          if (existingValidRedemption) {
+            logger.info("adapter.coupon.redeem.duplicate_team_seat", {
+              couponId: coupon.id,
+              currentUserId,
+              email,
+              productId,
+              purchaseId: existingValidRedemption.id,
+              userId: user.id
+            });
+            return {
+              error: {
+                message: "team-seat-redemption-already-claimed"
+              },
+              redeemingForCurrentUser,
+              purchase: null
+            };
+          }
+        }
+        const existingPurchases = await operations.getExistingNonBulkValidPurchasesOfProduct({
+          userId: user.id,
+          productId
+        });
+        if (existingPurchases.length > 0) {
+          const errorMessage = `already-purchased-${email}`;
+          logger.info("adapter.coupon.redeem.already_purchased", {
+            couponId: coupon.id,
+            currentUserId,
+            email,
+            productId,
+            userId: user.id
+          });
+          return {
+            error: {
+              message: errorMessage
+            },
+            redeemingForCurrentUser,
+            purchase: null
+          };
+          throw new Error(errorMessage);
+        }
+        const purchaseId = `purchase-${v4()}`;
+        const userMemberships = await operations.getMembershipsForUser(user.id);
+        const organizationId = coupon.organizationId || userMemberships.find((m) => m.organization.name?.includes(user.email))?.organizationId;
+        await operations.createPurchase({
+          id: purchaseId,
+          userId: user.id,
+          couponId: bulkCouponRedemption ? null : coupon.id,
+          redeemedBulkCouponId: bulkCouponRedemption ? coupon.id : null,
+          productId,
+          totalAmount: "0",
+          organizationId,
+          metadata: {
+            couponUsedId: bulkCouponRedemption ? null : coupon.id
+          }
+        });
+        const newPurchase = await operations.getPurchase(purchaseId);
+        await operations.incrementCouponUsedCount(coupon.id);
+        await operations.createPurchaseTransfer({
+          sourceUserId: user.id,
+          purchaseId,
+          expiresAt: new Date(Date.now() + 1e3 * 60 * 60 * 24 * 7)
+        });
+        return {
+          purchase: newPurchase,
+          redeemingForCurrentUser
+        };
+      }
+      return null;
+    }
+  };
+}
+__name(createRedeemFullPriceCouponWorkflow, "createRedeemFullPriceCouponWorkflow");
+
+export {
+  createRedeemFullPriceCouponWorkflow
+};
+//# sourceMappingURL=chunk-5FLS4ZBX.js.map

package/dist/chunk-5YR5M22S.js

@@ -0,0 +1,147 @@
+import {
+  external_exports
+} from "./chunk-QKOSV34V.js";
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/ports/organization.ts
+import { and, eq } from "drizzle-orm";
+import { OrganizationMemberSchema } from "@coursebuilder/core/schemas/organization-member";
+import { OrganizationSchema } from "@coursebuilder/core/schemas/organization-schema";
+function createOrganizationPort({ client, tables }) {
+  const { organization: organizationTable, organizationMemberships: organizationMembershipTable, organizationMembershipRoles: organizationMembershipRoleTable, roles: roleTable } = tables;
+  const getOrganization = /* @__PURE__ */ __name(async (organizationId) => {
+    return OrganizationSchema.parse(await client.query.organization.findFirst({
+      where: eq(organizationTable.id, organizationId)
+    }));
+  }, "getOrganization");
+  const getPersonalOrganization = /* @__PURE__ */ __name(async (userId) => {
+    return OrganizationSchema.nullable().parse(await client.query.organization.findFirst({
+      where: eq(organizationTable.personalOrganizationUserId, userId)
+    }) ?? null);
+  }, "getPersonalOrganization");
+  return {
+    createOrganization: async (options) => {
+      const organizationId = crypto.randomUUID();
+      await client.insert(organizationTable).values({
+        ...options,
+        id: organizationId
+      });
+      return getOrganization(organizationId);
+    },
+    getOrganization,
+    getPersonalOrganization,
+    createPersonalOrganization: async ({ userId, name }) => {
+      await client.insert(organizationTable).values({
+        id: crypto.randomUUID(),
+        name,
+        personalOrganizationUserId: userId
+      }).onDuplicateKeyUpdate({
+        set: {
+          personalOrganizationUserId: userId
+        }
+      });
+      const organization = await getPersonalOrganization(userId);
+      if (!organization) {
+        throw new Error("Failed to create durable personal organization");
+      }
+      return organization;
+    },
+    addMemberToOrganization: async (options) => {
+      const membershipWhere = options.personalOrganizationUserId ? eq(organizationMembershipTable.personalOrganizationUserId, options.personalOrganizationUserId) : and(eq(organizationMembershipTable.organizationId, options.organizationId), eq(organizationMembershipTable.userId, options.userId));
+      const currentMembership = await client.query.organizationMemberships.findFirst({
+        where: membershipWhere,
+        with: {
+          organization: true,
+          user: true
+        }
+      });
+      if (!currentMembership) {
+        const insert = client.insert(organizationMembershipTable).values({
+          ...options,
+          id: crypto.randomUUID()
+        });
+        if (options.personalOrganizationUserId) {
+          await insert.onDuplicateKeyUpdate({
+            set: {
+              userId: options.userId
+            }
+          });
+        } else {
+          await insert;
+        }
+      }
+      return OrganizationMemberSchema.parse(await client.query.organizationMemberships.findFirst({
+        where: membershipWhere,
+        with: {
+          organization: true,
+          user: true
+        }
+      }));
+    },
+    removeMemberFromOrganization: async (options) => {
+      await client.delete(organizationMembershipTable).where(and(eq(organizationMembershipTable.organizationId, options.organizationId), eq(organizationMembershipTable.userId, options.userId)));
+    },
+    addRoleForMember: async (options) => {
+      await client.insert(roleTable).values({
+        name: options.role,
+        organizationId: options.organizationId,
+        id: crypto.randomUUID()
+      }).onDuplicateKeyUpdate({
+        set: {
+          name: options.role
+        }
+      });
+      const role = external_exports.object({
+        id: external_exports.string()
+      }).parse(await client.query.roles.findFirst({
+        where: and(eq(roleTable.organizationId, options.organizationId), eq(roleTable.name, options.role))
+      }));
+      await client.insert(organizationMembershipRoleTable).values({
+        organizationId: options.organizationId,
+        organizationMembershipId: options.memberId,
+        roleId: role.id
+      }).onDuplicateKeyUpdate({
+        set: {
+          roleId: role.id
+        }
+      });
+    },
+    removeRoleForMember: async (options) => {
+      const existingRole = external_exports.object({
+        id: external_exports.string()
+      }).nullable().parse(await client.query.roles.findFirst({
+        where: and(eq(roleTable.organizationId, options.organizationId), eq(roleTable.name, options.role))
+      }));
+      const roleId = existingRole?.id;
+      if (roleId) {
+        await client.delete(organizationMembershipRoleTable).where(and(eq(organizationMembershipRoleTable.roleId, roleId), eq(organizationMembershipRoleTable.organizationMembershipId, options.memberId)));
+      }
+    },
+    getMembershipsForUser: async (userId) => {
+      return OrganizationMemberSchema.array().parse(await client.query.organizationMemberships.findMany({
+        where: eq(organizationMembershipTable.userId, userId),
+        with: {
+          organization: true,
+          user: true
+        }
+      }) || []);
+    },
+    getOrganizationMembers: async (organizationId) => {
+      return OrganizationMemberSchema.array().parse(await client.query.organizationMemberships.findMany({
+        where: eq(organizationMembershipTable.organizationId, organizationId),
+        with: {
+          organization: true,
+          user: true
+        }
+      }) || []);
+    }
+  };
+}
+__name(createOrganizationPort, "createOrganizationPort");
+
+export {
+  createOrganizationPort
+};
+//# sourceMappingURL=chunk-5YR5M22S.js.map

package/dist/chunk-6XQ6C3IX.js

@@ -0,0 +1,18 @@
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/workflows/content-resource-workflow-utils.ts
+import { customAlphabet } from "nanoid";
+var guid = customAlphabet("1234567890abcdefghijklmnopqrstuvwxyz", 5);
+var normalizeExpirationDate = /* @__PURE__ */ __name((date) => {
+  if (!date)
+    return void 0;
+  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), 23, 59, 59, 0));
+}, "normalizeExpirationDate");
+
+export {
+  guid,
+  normalizeExpirationDate
+};
+//# sourceMappingURL=chunk-6XQ6C3IX.js.map

package/dist/chunk-AIDM2CH6.js

@@ -0,0 +1,146 @@
+import {
+  guid,
+  normalizeExpirationDate
+} from "./chunk-6XQ6C3IX.js";
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/workflows/create-cohort.ts
+import slugify from "@sindresorhus/slugify";
+import { asc, eq } from "drizzle-orm";
+import { ContentResourceSchema } from "@coursebuilder/core/schemas/content-resource-schema";
+import { logger as baseLogger } from "@coursebuilder/utils/logger";
+var logger = baseLogger;
+function createCohortWorkflow({ client, tables }, operations) {
+  const { contentResource, contentResourceResource, contentResourceProduct, contentResourceTag } = tables;
+  return {
+    async createCohort(input, userId) {
+      const hash = guid();
+      const cohortId = `cohort~${hash}`;
+      const cohort = await client.transaction(async (tx) => {
+        await tx.insert(contentResource).values({
+          id: cohortId,
+          type: "cohort",
+          createdById: userId,
+          fields: {
+            title: input.cohort.title,
+            description: input.cohort.description,
+            state: "draft",
+            visibility: "unlisted",
+            slug: slugify(`${input.cohort.title}~${hash}`),
+            startsAt: input.dates.start,
+            endsAt: input.dates.end
+          }
+        });
+        const cohort2 = await tx.query.contentResource.findFirst({
+          where: eq(contentResource.id, cohortId),
+          with: {
+            resources: {
+              with: {
+                resource: true
+              },
+              orderBy: asc(contentResourceResource.position)
+            }
+          }
+        });
+        if (!cohort2) {
+          throw new Error("Failed to create cohort");
+        }
+        const parsedCohort = ContentResourceSchema.safeParse(cohort2);
+        if (!parsedCohort.success) {
+          throw new Error("Invalid cohort data");
+        }
+        if (input.cohort.tagIds) {
+          await tx.insert(contentResourceTag).values(input.cohort.tagIds.map((tag) => ({
+            contentResourceId: cohortId,
+            tagId: tag.id,
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date(),
+            position: 0
+          })));
+        }
+        let position = 0;
+        for (const workshop of input.workshops) {
+          await tx.insert(contentResourceResource).values({
+            resourceOfId: cohortId,
+            resourceId: workshop.id,
+            position
+          });
+          position++;
+        }
+        return parsedCohort.data;
+      });
+      let product = null;
+      if (input.createProduct && input.pricing.price && input.pricing.price > 0) {
+        try {
+          product = await operations.createProduct({
+            name: input.cohort.title,
+            price: input.pricing.price,
+            quantityAvailable: -1,
+            type: "cohort",
+            state: "published",
+            visibility: "public",
+            openEnrollment: (/* @__PURE__ */ new Date()).toISOString(),
+            closeEnrollment: input.dates.start.toISOString()
+          });
+          if (product) {
+            await client.insert(contentResourceProduct).values({
+              resourceId: cohortId,
+              productId: product.id,
+              position: 0,
+              metadata: {
+                addedBy: userId
+              }
+            });
+            if (input.coupon?.enabled && input.coupon.percentageDiscount && input.coupon.expires) {
+              try {
+                const finalExpires = normalizeExpirationDate(input.coupon.expires);
+                await operations.createCoupon({
+                  percentageDiscount: input.coupon.percentageDiscount,
+                  expires: finalExpires || null,
+                  restrictedToProductId: product.id,
+                  default: true,
+                  maxUses: -1,
+                  quantity: "-1",
+                  status: 1,
+                  fields: {}
+                });
+                logger.debug("cohort.create.coupon.success", {
+                  cohortId,
+                  productId: product.id,
+                  userId,
+                  percentageDiscount: input.coupon.percentageDiscount
+                });
+              } catch (couponError) {
+                logger.error(new Error(`Failed to create coupon for cohort: ${couponError}`));
+                logger.debug("cohort.create.coupon.failed", {
+                  cohortId,
+                  productId: product.id,
+                  userId
+                });
+              }
+            }
+          }
+        } catch (productError) {
+          logger.error(new Error(`Failed to create product for cohort: ${productError}`));
+          logger.debug("cohort.create.product.failed", {
+            cohortId,
+            userId,
+            price: input.pricing.price
+          });
+        }
+      }
+      return {
+        cohort,
+        product
+      };
+    }
+  };
+}
+__name(createCohortWorkflow, "createCohortWorkflow");
+
+export {
+  createCohortWorkflow
+};
+//# sourceMappingURL=chunk-AIDM2CH6.js.map