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

package/dist/chunk-2CTSX6SR.js

@@ -0,0 +1,145 @@
+import {
+  __name
+} from "./chunk-H736K5TN.js";
+
+// src/lib/mysql/ports/organization.ts
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+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 = z.object({
+        id: z.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 = z.object({
+        id: z.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-2CTSX6SR.js.map

package/dist/chunk-2M2XM4EQ.js

@@ -0,0 +1,397 @@
+import {
+  __name
+} from "./chunk-H736K5TN.js";
+
+// src/lib/mysql/ports/catalog.ts
+import slugify from "@sindresorhus/slugify";
+import { and, eq, inArray, or, sql } from "drizzle-orm";
+import { customAlphabet } from "nanoid";
+import { v4 } from "uuid";
+import { z } from "zod";
+import { merchantPriceSchema, merchantProductSchema, priceSchema, productSchema, upgradableProductSchema } from "@coursebuilder/core/schemas";
+import { ContentResourceProductSchema, ContentResourceSchema } from "@coursebuilder/core/schemas/content-resource-schema";
+import { merchantAccountSchema } from "@coursebuilder/core/schemas/merchant-account-schema";
+import { logger as baseLogger } from "@coursebuilder/utils/logger";
+var guid = customAlphabet("1234567890abcdefghijklmnopqrstuvwxyz", 5);
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+__name(toError, "toError");
+var logger = baseLogger;
+function createCatalogPort({ client, tables }, paymentProvider) {
+  const { contentResource, contentResourceProduct, merchantAccount, merchantPrice, merchantProduct, prices, products, purchases: purchaseTable, upgradableProducts } = tables;
+  const getProduct = /* @__PURE__ */ __name(async (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) {
+        logger.error(parsedProduct.error, {
+          event: "adapter.product.parse_failed",
+          productId: productData?.id,
+          productSlugOrId
+        });
+        return null;
+      }
+      return parsedProduct.data;
+    } catch (e) {
+      logger.error(toError(e), {
+        event: "adapter.product.lookup.failed",
+        productSlugOrId,
+        withResources
+      });
+      return null;
+    }
+  }, "getProduct");
+  return {
+    getProduct,
+    getUpgradableProducts: async (options) => {
+      const { upgradableFromId, upgradableToId } = options;
+      return z.array(upgradableProductSchema).parse(await client.query.upgradableProducts.findMany({
+        where: and(eq(upgradableProducts.upgradableFromId, upgradableFromId), eq(upgradableProducts.upgradableToId, upgradableToId))
+      }));
+    },
+    async availableUpgradesForProduct(purchases, productId) {
+      const previousPurchaseProductIds = purchases.map(({ productId: productId2 }) => productId2);
+      if (previousPurchaseProductIds.length > 0) {
+        return client.query.upgradableProducts.findMany({
+          where: and(eq(upgradableProducts.upgradableToId, productId), inArray(upgradableProducts.upgradableFromId, previousPurchaseProductIds))
+        });
+      }
+      return [];
+    },
+    async getPrice(productId) {
+      return priceSchema.nullable().parse(await client.query.prices.findFirst({
+        where: eq(prices.productId, productId)
+      }));
+    },
+    async getPriceForProduct(productId) {
+      return priceSchema.nullable().parse(await client.query.prices.findFirst({
+        where: eq(prices.productId, productId)
+      }));
+    },
+    async archiveProduct(productId) {
+      if (!paymentProvider)
+        throw new Error("Payment provider not found");
+      const product = await 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: eq(merchantPrice.priceId, product.price.id)
+      }));
+      if (!currentMerchantPrice || !currentMerchantPrice.identifier) {
+        throw new Error(`Merchant price not found for id (${productId})`);
+      }
+      await paymentProvider.updatePrice(currentMerchantPrice.identifier, {
+        active: false
+      });
+      return getProduct(productId);
+    },
+    async updateProduct(input) {
+      if (!paymentProvider)
+        throw new Error("Payment provider not found");
+      const currentProduct = await 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();
+      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 membershipTypeChanged = currentProduct.type !== input.type && (input.type === "membership" || currentProduct.type === "membership");
+      const billingIntervalChanged = input.type === "membership" && currentProduct.type === "membership" && currentProduct.fields?.billingInterval !== input.fields?.billingInterval;
+      const isMembership = input.type === "membership";
+      const stripePriceMismatch = isMembership !== !!currentStripePrice.recurring;
+      const needsPriceRecreation = priceChanged || membershipTypeChanged || billingIntervalChanged || stripePriceMismatch;
+      if (needsPriceRecreation) {
+        const billingInterval = input.fields?.billingInterval || "year";
+        const priceParams = {
+          product: stripeProduct.id,
+          unit_amount: Math.floor(Number(input.price?.unitAmount || 0) * 100),
+          currency: "usd",
+          metadata: {
+            slug: input.fields.slug
+          },
+          active: true,
+          // Membership products get recurring billing
+          ...input.type === "membership" && {
+            recurring: {
+              interval: billingInterval
+            }
+          }
+        };
+        logger.debug("adapter.product.price_recreation.started", {
+          billingInterval,
+          currency: priceParams.currency,
+          currentMerchantPriceId: currentMerchantPrice.id,
+          isMembership: input.type === "membership",
+          merchantProductId: merchantProduct2.id,
+          productId: input.id,
+          productSlug: input.fields.slug,
+          stripeProductId: stripeProduct.id,
+          unitAmount: priceParams.unit_amount
+        });
+        const newStripePrice = await paymentProvider.createPrice(priceParams);
+        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
+          }
+        },
+        type: input.type
+      }).where(eq(products.id, currentProduct.id));
+      return 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: input.type || "self-paced",
+        quantityAvailable: input.quantityAvailable,
+        fields: {
+          state: input.state || "draft",
+          visibility: input.visibility || "unlisted",
+          slug: slugify(`${input.name}-${hash}`),
+          ...input.openEnrollment && {
+            openEnrollment: input.openEnrollment
+          },
+          ...input.closeEnrollment && {
+            closeEnrollment: input.closeEnrollment
+          },
+          ...typeof input.availableAfterDays === "number" && {
+            availableAfterDays: input.availableAfterDays
+          },
+          ...typeof input.accessDurationDays === "number" && {
+            accessDurationDays: input.accessDurationDays
+          }
+        }
+      };
+      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 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
+        },
+        // Membership products get recurring billing
+        ...input.type === "membership" && {
+          recurring: {
+            interval: input.billingInterval || "year"
+          }
+        }
+      });
+      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 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 pricesOfPurchasesTowardOneBundle({ userId, bundleId }) {
+      if (userId === void 0)
+        return [];
+      const canUpgradeProducts = await client.query.upgradableProducts.findMany({
+        where: eq(upgradableProducts.upgradableToId, bundleId)
+      });
+      const upgradableFrom = z.array(z.string()).parse(canUpgradeProducts.map((product) => {
+        return product.upgradableFromId;
+      }));
+      const purchases = await client.query.purchases.findMany({
+        where: and(eq(purchaseTable.userId, userId), inArray(purchaseTable.productId, upgradableFrom))
+      });
+      const productsPurchased = z.array(z.string()).parse(purchases.map((purchase) => {
+        return purchase.productId;
+      }));
+      if (productsPurchased.length === 0)
+        return [];
+      const foundPrices = await client.query.prices.findMany({
+        where: inArray(prices.productId, productsPurchased)
+      });
+      return z.array(priceSchema).parse(foundPrices);
+    },
+    async addResourceToProduct(options) {
+      const { resource, productId, userId } = options;
+      const product = await getProduct(productId);
+      if (!product) {
+        throw new Error(`Product not found for id (${productId})`);
+      }
+      await client.insert(contentResourceProduct).values({
+        resourceId: resource.id,
+        productId,
+        position: product.resources?.length || 0,
+        metadata: {
+          addedBy: userId
+        }
+      });
+      const resourceProduct = await client.query.contentResourceProduct.findFirst({
+        where: eq(contentResourceProduct.resourceId, resource.id),
+        with: {
+          resource: true,
+          product: true
+        }
+      });
+      return ContentResourceProductSchema.safeParse(resourceProduct).data || null;
+    }
+  };
+}
+__name(createCatalogPort, "createCatalogPort");
+
+export {
+  createCatalogPort
+};
+//# sourceMappingURL=chunk-2M2XM4EQ.js.map