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

package/dist/chunk-H5REZLWW.js

@@ -0,0 +1,63 @@
+import {
+  __name
+} from "./chunk-H736K5TN.js";
+
+// src/lib/mysql/ports/auth-storage.ts
+import { addSeconds, isAfter } from "date-fns";
+import { and, eq } from "drizzle-orm";
+function createAuthStoragePort({ client, tables }) {
+  const { accounts, sessions, users, verificationTokens } = tables;
+  return {
+    createSession: async (data) => {
+      await client.insert(sessions).values(data);
+      return await client.select().from(sessions).where(eq(sessions.sessionToken, data.sessionToken)).then((res) => res[0]);
+    },
+    getSessionAndUser: async (data) => {
+      return await client.select({
+        session: sessions,
+        user: users
+      }).from(sessions).where(eq(sessions.sessionToken, data)).innerJoin(users, eq(users.id, sessions.userId)).then((res) => res[0]) ?? null;
+    },
+    updateSession: async (data) => {
+      await client.update(sessions).set(data).where(eq(sessions.sessionToken, data.sessionToken));
+      return await client.select().from(sessions).where(eq(sessions.sessionToken, data.sessionToken)).then((res) => res[0]);
+    },
+    deleteSession: async (sessionToken) => {
+      const session = await client.select().from(sessions).where(eq(sessions.sessionToken, sessionToken)).then((res) => res[0]) ?? null;
+      await client.delete(sessions).where(eq(sessions.sessionToken, sessionToken));
+      return session;
+    },
+    useVerificationToken: async (token) => {
+      try {
+        const deletedToken = await client.select().from(verificationTokens).where(and(eq(verificationTokens.identifier, token.identifier), eq(verificationTokens.token, token.token))).then((res) => res[0]) ?? null;
+        if (deletedToken?.createdAt) {
+          const TIMEOUT_IN_SECONDS = 90;
+          const expireMultipleClicks = addSeconds(deletedToken.createdAt, TIMEOUT_IN_SECONDS);
+          const now = /* @__PURE__ */ new Date();
+          if (isAfter(expireMultipleClicks, now)) {
+            const { id: _, ...verificationToken } = token;
+            return deletedToken;
+          }
+          await client.delete(verificationTokens).where(and(eq(verificationTokens.identifier, token.identifier), eq(verificationTokens.token, token.token)));
+          return deletedToken;
+        }
+        return deletedToken;
+      } catch (err) {
+        throw new Error("No verification token found.");
+      }
+    },
+    deleteUser: async (id) => {
+      const user = await client.select().from(users).where(eq(users.id, id)).then((res) => res[0] ?? null);
+      await client.delete(users).where(eq(users.id, id));
+      await client.delete(sessions).where(eq(sessions.userId, id));
+      await client.delete(accounts).where(eq(accounts.userId, id));
+      return user;
+    }
+  };
+}
+__name(createAuthStoragePort, "createAuthStoragePort");
+
+export {
+  createAuthStoragePort
+};
+//# sourceMappingURL=chunk-H5REZLWW.js.map

package/dist/chunk-H736K5TN.js

@@ -0,0 +1,7 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+export {
+  __name
+};
+//# sourceMappingURL=chunk-H736K5TN.js.map

package/dist/{chunk-WWBSNLRC.js → chunk-HJNM3PFW.js}

@@ -1,9 +1,9 @@
 import {
   getUsersSchema
-} from "./chunk-PNPTKVJ4.js";
+} from "./chunk-QGSAYLPA.js";
 import {
   __name
-} from "./chunk-2X5XVNDN.js";
+} from "./chunk-H736K5TN.js";
 
 // src/lib/mysql/schemas/auth/device-verification.ts
 import { relations, sql } from "drizzle-orm";
@@ -60,4 +60,4 @@ export {
   getDeviceVerificationSchema,
   getDeviceVerificationRelationsSchema
 };
-//# sourceMappingURL=chunk-WWBSNLRC.js.map
+//# sourceMappingURL=chunk-HJNM3PFW.js.map

package/dist/chunk-JNPUM2MI.js

@@ -0,0 +1,156 @@
+import {
+  guid,
+  normalizeExpirationDate
+} from "./chunk-OWBFASNN.js";
+import {
+  __name
+} from "./chunk-H736K5TN.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-JNPUM2MI.js.map

package/dist/{chunk-2I7NIOKI.js → chunk-KPBVZ44W.js}

@@ -1,6 +1,6 @@
 import {
   __name
-} from "./chunk-2X5XVNDN.js";
+} from "./chunk-H736K5TN.js";
 
 // src/lib/mysql/schemas/commerce/merchant-product.ts
 import { sql } from "drizzle-orm";
@@ -45,4 +45,4 @@ __name(getMerchantProductSchema, "getMerchantProductSchema");
 export {
   getMerchantProductSchema
 };
-//# sourceMappingURL=chunk-2I7NIOKI.js.map
+//# sourceMappingURL=chunk-KPBVZ44W.js.map

package/dist/{chunk-OUJPUONP.js → chunk-LERR6HQ3.js}

@@ -1,6 +1,6 @@
 import {
   __name
-} from "./chunk-2X5XVNDN.js";
+} from "./chunk-H736K5TN.js";
 
 // src/lib/mysql/schemas/auth/verification-tokens.ts
 import { primaryKey, timestamp, varchar } from "drizzle-orm/mysql-core";
@@ -33,4 +33,4 @@ __name(getVerificationTokensSchema, "getVerificationTokensSchema");
 export {
   getVerificationTokensSchema
 };
-//# sourceMappingURL=chunk-OUJPUONP.js.map
+//# sourceMappingURL=chunk-LERR6HQ3.js.map

package/dist/chunk-LSWGCJWO.js

@@ -0,0 +1,328 @@
+import {
+  __name
+} from "./chunk-H736K5TN.js";
+
+// src/lib/mysql/ports/purchase.ts
+import { and, asc, eq, inArray, isNull, not, or } from "drizzle-orm";
+import { v4 } from "uuid";
+import { z } from "zod";
+import { merchantChargeSchema, purchaseSchema, purchaseUserTransferSchema, upgradableProductSchema, 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 createPurchasePort({ client, tables }) {
+  const { purchases: purchaseTable, purchaseUserTransfer, merchantCharge, merchantCustomer, merchantSession, upgradableProducts } = tables;
+  const purchasePort = {
+    createPurchaseTransfer: async (options) => {
+      const id = `put_${v4()}`;
+      await client.insert(purchaseUserTransfer).values({
+        id,
+        purchaseId: options.purchaseId,
+        sourceUserId: options.sourceUserId,
+        expiresAt: options.expiresAt
+      });
+    },
+    getExistingNonBulkValidPurchasesOfProduct: async ({ userId, productId }) => {
+      const existingPurchases = await client.query.purchases.findMany({
+        where: and(eq(purchaseTable.userId, userId), productId ? eq(purchaseTable.productId, productId) : void 0, eq(purchaseTable.status, "Valid"), isNull(purchaseTable.bulkCouponId))
+      });
+      return z.array(purchaseSchema).parse(existingPurchases);
+    },
+    async getPurchasesForBulkCouponId(bulkCouponId) {
+      return z.array(purchaseSchema.extend({
+        user: userSchema
+      })).parse(await client.query.purchases.findMany({
+        where: eq(purchaseTable.bulkCouponId, bulkCouponId),
+        with: {
+          user: true
+        }
+      }));
+    },
+    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({
+        where: eq(purchaseTable.id, purchaseId)
+      });
+      return purchase ? purchaseSchema.parse(purchase) : null;
+    },
+    async createPurchase(options) {
+      const newPurchaseId = options.id || `purchase-${v4()}`;
+      await client.insert(purchaseTable).values({
+        ...options,
+        id: newPurchaseId
+      });
+      const newPurchase = await purchasePort.getPurchase(newPurchaseId);
+      return purchaseSchema.parse(newPurchase);
+    },
+    async getPurchaseForStripeCharge(stripeChargeId) {
+      logger.debug("getPurchaseForStripeCharge", {
+        stripeChargeId
+      });
+      const chargeForPurchase = merchantChargeSchema.nullable().parse(await client.query.merchantCharge.findFirst({
+        where: eq(merchantCharge.identifier, stripeChargeId)
+      }) || null);
+      if (!chargeForPurchase) {
+        logger.debug("getPurchaseForStripeCharge: no matching charge", {
+          stripeChargeId,
+          idPrefix: stripeChargeId?.substring(0, 3)
+        });
+        return null;
+      }
+      const purchase = purchaseSchema.safeParse(await client.query.purchases.findFirst({
+        where: eq(purchaseTable.merchantChargeId, chargeForPurchase.id),
+        with: {
+          user: true,
+          product: true,
+          bulkCoupon: true
+        }
+      }));
+      if (!purchase.success) {
+        return null;
+      }
+      return purchase.data;
+    },
+    async getPurchaseByCheckoutSessionId(checkoutSessionId) {
+      logger.debug("getPurchaseByCheckoutSessionId", {
+        checkoutSessionId
+      });
+      const session = await client.query.merchantSession.findFirst({
+        where: eq(merchantSession.identifier, checkoutSessionId)
+      });
+      if (!session) {
+        logger.debug("getPurchaseByCheckoutSessionId: no matching session", {
+          checkoutSessionId
+        });
+        return null;
+      }
+      const purchase = purchaseSchema.safeParse(await client.query.purchases.findFirst({
+        where: eq(purchaseTable.merchantSessionId, String(session.id)),
+        with: {
+          user: true,
+          product: true,
+          bulkCoupon: true
+        }
+      }));
+      if (!purchase.success) {
+        return null;
+      }
+      return purchase.data;
+    },
+    async getPurchaseUserTransferById(options) {
+      const purchaseTransferData = await client.query.purchaseUserTransfer.findFirst({
+        where: eq(purchaseUserTransfer.id, options.id),
+        with: {
+          sourceUser: true,
+          targetUser: true,
+          purchase: true
+        }
+      });
+      return purchaseUserTransferSchema.merge(z.object({
+        sourceUser: userSchema,
+        targetUser: userSchema.nullable(),
+        purchase: purchaseSchema,
+        organizationId: z.string().nullable()
+      })).nullable().parse(purchaseTransferData);
+    },
+    async getPurchaseWithUser(purchaseId) {
+      const purchaseData = await client.query.purchases.findFirst({
+        where: eq(purchaseTable.id, purchaseId),
+        with: {
+          user: true
+        }
+      }) || null;
+      const parsedPurchase = purchaseSchema.merge(z.object({
+        user: userSchema
+      })).nullable().safeParse(purchaseData);
+      if (!parsedPurchase.success) {
+        logger.error(parsedPurchase.error, {
+          event: "adapter.purchase.parse_failed",
+          purchaseId
+        });
+        return null;
+      }
+      return parsedPurchase.data;
+    },
+    async getPurchasesForUser(userId) {
+      if (!userId) {
+        return [];
+      }
+      const visiblePurchaseStates = [
+        "Valid",
+        "Refunded",
+        "Restricted"
+      ];
+      const userPurchases = await client.query.purchases.findMany({
+        where: and(eq(purchaseTable.userId, userId), inArray(purchaseTable.status, visiblePurchaseStates)),
+        with: {
+          user: true,
+          product: true,
+          bulkCoupon: true
+        },
+        orderBy: asc(purchaseTable.createdAt)
+      });
+      const parsedPurchases = z.array(purchaseSchema).safeParse(userPurchases);
+      if (!parsedPurchases.success) {
+        logger.error(parsedPurchases.error, {
+          event: "adapter.purchase.list.parse_failed",
+          purchaseCount: userPurchases.length,
+          userId
+        });
+        return [];
+      }
+      return parsedPurchases.data;
+    },
+    async getPurchaseDetails(purchaseId, userId) {
+      const visiblePurchaseStates = [
+        "Valid",
+        "Refunded",
+        "Restricted"
+      ];
+      const userPurchases = await client.query.purchases.findMany({
+        where: and(eq(purchaseTable.userId, userId), inArray(purchaseTable.status, visiblePurchaseStates)),
+        with: {
+          user: true,
+          product: true,
+          bulkCoupon: true
+        },
+        orderBy: asc(purchaseTable.createdAt)
+      });
+      const parsedPurchases = z.array(purchaseSchema).safeParse(userPurchases);
+      const allPurchases = parsedPurchases.success ? parsedPurchases.data : [];
+      const thePurchase = await client.query.purchases.findFirst({
+        where: and(eq(purchaseTable.id, purchaseId), eq(purchaseTable.userId, userId)),
+        with: {
+          user: true,
+          product: true,
+          bulkCoupon: true
+        }
+      });
+      const parsedPurchase = purchaseSchema.safeParse(thePurchase);
+      if (!parsedPurchase.success) {
+        logger.error(parsedPurchase.error, {
+          event: "adapter.purchase.details.parse_failed",
+          purchaseId,
+          userId
+        });
+        return {
+          availableUpgrades: []
+        };
+      }
+      const purchaseCanUpgrade = [
+        "Valid",
+        "Restricted"
+      ].includes(parsedPurchase.data.state || "");
+      let availableUpgrades = [];
+      if (purchaseCanUpgrade) {
+        availableUpgrades = await client.query.upgradableProducts.findMany({
+          where: and(eq(upgradableProducts.upgradableFromId, parsedPurchase.data.product?.id), not(inArray(upgradableProducts.upgradableToId, allPurchases.map((p) => p.product?.id)))),
+          with: {
+            upgradableTo: true,
+            upgradableFrom: true
+          }
+        });
+      }
+      const existingPurchase = purchaseSchema.optional().nullable().parse(await client.query.purchases.findFirst({
+        where: and(eq(purchaseTable.userId, userId), eq(purchaseTable.productId, parsedPurchase.data.productId), inArray(purchaseTable.status, [
+          "Valid",
+          "Restricted"
+        ]), isNull(purchaseTable.bulkCouponId), not(eq(purchaseTable.id, parsedPurchase.data.id))),
+        with: {
+          user: true,
+          product: true,
+          bulkCoupon: true
+        }
+      }) || null);
+      return {
+        availableUpgrades: z.array(upgradableProductSchema).parse(availableUpgrades),
+        existingPurchase,
+        purchase: parsedPurchase.data
+      };
+    },
+    async transferPurchasesToNewUser(options) {
+      await client.transaction(async (trx) => {
+        const charges = await trx.select({
+          id: merchantCharge.id
+        }).from(merchantCharge).where(eq(merchantCharge.merchantCustomerId, options.merchantCustomerId));
+        const chargeIds = charges.map(({ id }) => id);
+        if (chargeIds.length > 0) {
+          await trx.update(purchaseTable).set({
+            userId: options.userId
+          }).where(inArray(purchaseTable.merchantChargeId, chargeIds));
+          await trx.update(merchantCharge).set({
+            userId: options.userId
+          }).where(inArray(merchantCharge.id, chargeIds));
+        }
+        await trx.update(merchantCustomer).set({
+          userId: options.userId
+        }).where(eq(merchantCustomer.id, options.merchantCustomerId));
+      });
+    },
+    async updatePurchaseStatusForCharge(chargeId, status) {
+      try {
+        logger.debug("adapter.purchase.status_update.started", {
+          chargeId,
+          status
+        });
+        const merchantChargeForPurchase = await client.query.merchantCharge.findFirst({
+          where: or(eq(merchantCharge.identifier, chargeId), eq(merchantCharge.id, chargeId))
+        });
+        logger.debug("adapter.purchase.status_update.charge_resolved", {
+          chargeId,
+          merchantChargeId: merchantChargeForPurchase?.id ?? null,
+          merchantChargeIdentifier: merchantChargeForPurchase?.identifier ?? null
+        });
+        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) {
+        logger.error(toError(e), {
+          chargeId,
+          event: "adapter.purchase.status_update.failed",
+          status
+        });
+        throw e;
+      }
+    },
+    async updatePurchaseUserTransferTransferState(options) {
+      await client.update(purchaseUserTransfer).set({
+        transferState: options.transferState
+      }).where(eq(purchaseUserTransfer.id, options.id));
+      const purchaseUserTransferData = await client.query.purchaseUserTransfer.findFirst({
+        where: eq(purchaseUserTransfer.id, options.id)
+      }) || null;
+      return purchaseUserTransferSchema.nullable().parse(purchaseUserTransferData);
+    }
+  };
+  return purchasePort;
+}
+__name(createPurchasePort, "createPurchasePort");
+
+export {
+  createPurchasePort
+};
+//# sourceMappingURL=chunk-LSWGCJWO.js.map

package/dist/{chunk-UWUDJCJM.js → chunk-LZHZDFNZ.js}

@@ -1,6 +1,6 @@
 import {
   __name
-} from "./chunk-2X5XVNDN.js";
+} from "./chunk-H736K5TN.js";
 
 // src/lib/mysql/schemas/auth/permissions.ts
 import { relations } from "drizzle-orm";
@@ -41,4 +41,4 @@ export {
   getPermissionsSchema,
   getPermissionsRelationsSchema
 };
-//# sourceMappingURL=chunk-UWUDJCJM.js.map
+//# sourceMappingURL=chunk-LZHZDFNZ.js.map

package/dist/{chunk-PMCOC5PM.js → chunk-MGZMGDQ5.js}

@@ -1,6 +1,6 @@
 import {
   __name
-} from "./chunk-2X5XVNDN.js";
+} from "./chunk-H736K5TN.js";
 
 // src/lib/mysql/schemas/commerce/merchant-price.ts
 import { sql } from "drizzle-orm";
@@ -48,4 +48,4 @@ __name(getMerchantPriceSchema, "getMerchantPriceSchema");
 export {
   getMerchantPriceSchema
 };
-//# sourceMappingURL=chunk-PMCOC5PM.js.map
+//# sourceMappingURL=chunk-MGZMGDQ5.js.map