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

package/dist/chunk-QQKNNFFB.js

@@ -0,0 +1,399 @@
+import {
+  external_exports
+} from "./chunk-QKOSV34V.js";
+import {
+  __name
+} from "./chunk-2X5XVNDN.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 { 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 external_exports.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 = external_exports.array(ContentResourceProductSchema).nullable().parse(await client.query.contentResourceProduct.findMany({
+        where: eq(contentResourceProduct.productId, productId)
+      }));
+      if (!contentResourceProductsForProduct) {
+        return null;
+      } else {
+        const contentResources = external_exports.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 = external_exports.array(external_exports.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 = external_exports.array(external_exports.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 external_exports.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-QQKNNFFB.js.map

package/dist/chunk-RBHCV3UW.js

@@ -0,0 +1,20 @@
+import {
+  createTables
+} from "./chunk-TNH2C27F.js";
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/context.ts
+function createMySqlContext(client, tableFn) {
+  return {
+    client,
+    tables: createTables(tableFn)
+  };
+}
+__name(createMySqlContext, "createMySqlContext");
+
+export {
+  createMySqlContext
+};
+//# sourceMappingURL=chunk-RBHCV3UW.js.map

package/dist/chunk-TNH2C27F.js

@@ -0,0 +1,252 @@
+import {
+  getEntitlementTypesSchema
+} from "./chunk-OFZECDCQ.js";
+import {
+  getEntitlementRelationsSchema,
+  getEntitlementsSchema
+} from "./chunk-X7DRYXB7.js";
+import {
+  getLessonProgressSchema
+} from "./chunk-CCXVDMTA.js";
+import {
+  getResourceProgressSchema
+} from "./chunk-WMCZWSAG.js";
+import {
+  getUpgradableProductsRelationsSchema,
+  getUpgradableProductsSchema
+} from "./chunk-EIQBTF5J.js";
+import {
+  getQuestionResponseRelationsSchema,
+  getQuestionResponseSchema
+} from "./chunk-2GW3BJE2.js";
+import {
+  getPurchaseUserTransferRelationsSchema,
+  getPurchaseUserTransferSchema
+} from "./chunk-JVHX4JHA.js";
+import {
+  getVerificationTokensSchema
+} from "./chunk-OUJPUONP.js";
+import {
+  getMerchantEventsRelationsSchema,
+  getMerchantEventsSchema
+} from "./chunk-SOOAUY4E.js";
+import {
+  getRolePermissionsRelationsSchema,
+  getRolePermissionsSchema
+} from "./chunk-EDM6DKA5.js";
+import {
+  getSessionRelationsSchema,
+  getSessionsSchema
+} from "./chunk-INZTF6QV.js";
+import {
+  getDeviceAccessTokenRelationsSchema,
+  getDeviceAccessTokenSchema
+} from "./chunk-WUMDFFN3.js";
+import {
+  getDeviceVerificationRelationsSchema,
+  getDeviceVerificationSchema
+} from "./chunk-ZY4AFKUQ.js";
+import {
+  getPersonalAccessTokenRelationsSchema,
+  getPersonalAccessTokenSchema
+} from "./chunk-33ZN7FN7.js";
+import {
+  getAccountsRelationsSchema,
+  getAccountsSchema,
+  getCommentRelationsSchema,
+  getCommentsSchema,
+  getCommunicationPreferencesRelationsSchema,
+  getCommunicationPreferencesSchema,
+  getContentContributionRelationsSchema,
+  getContentContributionsSchema,
+  getContentResourceProductRelationsSchema,
+  getContentResourceProductSchema,
+  getContentResourceRelationsSchema,
+  getContentResourceResourceRelationsSchema,
+  getContentResourceResourceSchema,
+  getContentResourceSchema,
+  getContentResourceTagRelationsSchema,
+  getContentResourceTagSchema,
+  getContentResourceVersionRelationsSchema,
+  getContentResourceVersionSchema,
+  getCouponRelationsSchema,
+  getCouponSchema,
+  getMerchantChargeRelationsSchema,
+  getMerchantChargeSchema,
+  getMerchantSubscriptionRelationsSchema,
+  getMerchantSubscriptionSchema,
+  getOrganizationMembershipRolesRelationsSchema,
+  getOrganizationMembershipRolesSchema,
+  getOrganizationMembershipsRelationsSchema,
+  getOrganizationMembershipsSchema,
+  getOrganizationsRelationsSchema,
+  getOrganizationsSchema,
+  getPriceSchema,
+  getProductRelationsSchema2 as getProductRelationsSchema,
+  getProductSchema,
+  getProfilesRelationsSchema,
+  getProfilesSchema,
+  getPurchaseRelationsSchema,
+  getPurchaseSchema,
+  getRolesRelationsSchema,
+  getRolesSchema,
+  getSubscriptionRelationsSchema,
+  getSubscriptionSchema,
+  getTagRelationsSchema,
+  getTagSchema,
+  getTagTagRelationsSchema,
+  getTagTagSchema,
+  getUserPermissionsRelationsSchema,
+  getUserPermissionsSchema,
+  getUserPrefsRelationsSchema,
+  getUserPrefsSchema,
+  getUserRolesRelationsSchema,
+  getUserRolesSchema,
+  getUsersRelationsSchema,
+  getUsersSchema
+} from "./chunk-XUBZKYH6.js";
+import {
+  getContributionTypesRelationsSchema,
+  getContributionTypesSchema
+} from "./chunk-6SJORFGN.js";
+import {
+  getCommunicationChannelSchema
+} from "./chunk-65H5Y4PD.js";
+import {
+  getCommunicationPreferenceTypesSchema
+} from "./chunk-QKFITIXC.js";
+import {
+  getMerchantProductSchema
+} from "./chunk-2I7NIOKI.js";
+import {
+  getMerchantSessionSchema
+} from "./chunk-5NNBQJUP.js";
+import {
+  getMerchantCouponSchema
+} from "./chunk-NON5CXDH.js";
+import {
+  getMerchantCustomerSchema
+} from "./chunk-SIZFEXIS.js";
+import {
+  getMerchantAccountSchema
+} from "./chunk-DNBW5D64.js";
+import {
+  getMerchantPriceSchema
+} from "./chunk-PMCOC5PM.js";
+import {
+  getPermissionsRelationsSchema,
+  getPermissionsSchema
+} from "./chunk-UWUDJCJM.js";
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/schema.ts
+function getCourseBuilderSchema(mysqlTable, overrides = {}) {
+  const resolvedGetUsersSchema = overrides.getUsersSchema ?? getUsersSchema;
+  const userRelationsOverrides = {
+    getUsersSchema: resolvedGetUsersSchema
+  };
+  return {
+    accounts: getAccountsSchema(mysqlTable),
+    accountsRelations: getAccountsRelationsSchema(mysqlTable, userRelationsOverrides),
+    permissions: getPermissionsSchema(mysqlTable),
+    permissionsRelations: getPermissionsRelationsSchema(mysqlTable),
+    rolePermissions: getRolePermissionsSchema(mysqlTable),
+    rolePermissionsRelations: getRolePermissionsRelationsSchema(mysqlTable),
+    roles: getRolesSchema(mysqlTable),
+    rolesRelations: getRolesRelationsSchema(mysqlTable),
+    sessions: getSessionsSchema(mysqlTable),
+    sessionsRelations: getSessionRelationsSchema(mysqlTable, userRelationsOverrides),
+    userPermissions: getUserPermissionsSchema(mysqlTable),
+    userPermissionsRelations: getUserPermissionsRelationsSchema(mysqlTable, userRelationsOverrides),
+    userRoles: getUserRolesSchema(mysqlTable),
+    userRolesRelations: getUserRolesRelationsSchema(mysqlTable, userRelationsOverrides),
+    users: resolvedGetUsersSchema(mysqlTable),
+    usersRelations: getUsersRelationsSchema(mysqlTable, userRelationsOverrides),
+    verificationTokens: getVerificationTokensSchema(mysqlTable),
+    coupon: getCouponSchema(mysqlTable),
+    couponRelations: getCouponRelationsSchema(mysqlTable),
+    lessonProgress: getLessonProgressSchema(mysqlTable),
+    merchantAccount: getMerchantAccountSchema(mysqlTable),
+    merchantCharge: getMerchantChargeSchema(mysqlTable),
+    merchantChargeRelations: getMerchantChargeRelationsSchema(mysqlTable),
+    merchantEvents: getMerchantEventsSchema(mysqlTable),
+    merchantEventsRelations: getMerchantEventsRelationsSchema(mysqlTable),
+    merchantCoupon: getMerchantCouponSchema(mysqlTable),
+    merchantCustomer: getMerchantCustomerSchema(mysqlTable),
+    merchantPrice: getMerchantPriceSchema(mysqlTable),
+    merchantProduct: getMerchantProductSchema(mysqlTable),
+    merchantSession: getMerchantSessionSchema(mysqlTable),
+    prices: getPriceSchema(mysqlTable),
+    products: getProductSchema(mysqlTable),
+    purchases: getPurchaseSchema(mysqlTable),
+    purchaseRelations: getPurchaseRelationsSchema(mysqlTable, userRelationsOverrides),
+    purchaseUserTransfer: getPurchaseUserTransferSchema(mysqlTable),
+    purchaseUserTransferRelations: getPurchaseUserTransferRelationsSchema(mysqlTable, userRelationsOverrides),
+    communicationChannel: getCommunicationChannelSchema(mysqlTable),
+    communicationPreferenceTypes: getCommunicationPreferenceTypesSchema(mysqlTable),
+    communicationPreferences: getCommunicationPreferencesSchema(mysqlTable),
+    communicationPreferencesRelations: getCommunicationPreferencesRelationsSchema(mysqlTable, userRelationsOverrides),
+    contentContributions: getContentContributionsSchema(mysqlTable),
+    contentContributionRelations: getContentContributionRelationsSchema(mysqlTable, userRelationsOverrides),
+    contentResource: getContentResourceSchema(mysqlTable),
+    contentResourceVersion: getContentResourceVersionSchema(mysqlTable),
+    contentResourceVersionRelations: getContentResourceVersionRelationsSchema(mysqlTable, userRelationsOverrides),
+    contentResourceRelations: getContentResourceRelationsSchema(mysqlTable, userRelationsOverrides),
+    contentResourceResource: getContentResourceResourceSchema(mysqlTable),
+    contentResourceResourceRelations: getContentResourceResourceRelationsSchema(mysqlTable),
+    contentResourceTag: getContentResourceTagSchema(mysqlTable),
+    contentResourceTagRelations: getContentResourceTagRelationsSchema(mysqlTable),
+    contributionTypes: getContributionTypesSchema(mysqlTable),
+    contributionTypesRelations: getContributionTypesRelationsSchema(mysqlTable),
+    resourceProgress: getResourceProgressSchema(mysqlTable),
+    questionResponse: getQuestionResponseSchema(mysqlTable),
+    questionResponseRelations: getQuestionResponseRelationsSchema(mysqlTable, userRelationsOverrides),
+    upgradableProducts: getUpgradableProductsSchema(mysqlTable),
+    upgradableProductsRelations: getUpgradableProductsRelationsSchema(mysqlTable),
+    contentResourceProduct: getContentResourceProductSchema(mysqlTable),
+    contentResourceProductRelations: getContentResourceProductRelationsSchema(mysqlTable),
+    productRelations: getProductRelationsSchema(mysqlTable),
+    comments: getCommentsSchema(mysqlTable),
+    commentsRelations: getCommentRelationsSchema(mysqlTable, userRelationsOverrides),
+    deviceVerifications: getDeviceVerificationSchema(mysqlTable),
+    deviceVerificationRelations: getDeviceVerificationRelationsSchema(mysqlTable, userRelationsOverrides),
+    deviceAccessToken: getDeviceAccessTokenSchema(mysqlTable),
+    deviceAccessTokenRelations: getDeviceAccessTokenRelationsSchema(mysqlTable, userRelationsOverrides),
+    personalAccessToken: getPersonalAccessTokenSchema(mysqlTable),
+    personalAccessTokenRelations: getPersonalAccessTokenRelationsSchema(mysqlTable, userRelationsOverrides),
+    tag: getTagSchema(mysqlTable),
+    tagRelations: getTagRelationsSchema(mysqlTable),
+    tagTag: getTagTagSchema(mysqlTable),
+    tagTagRelations: getTagTagRelationsSchema(mysqlTable),
+    userPrefs: getUserPrefsSchema(mysqlTable),
+    userPrefsRelations: getUserPrefsRelationsSchema(mysqlTable, userRelationsOverrides),
+    organization: getOrganizationsSchema(mysqlTable),
+    organizationRelations: getOrganizationsRelationsSchema(mysqlTable),
+    organizationMemberships: getOrganizationMembershipsSchema(mysqlTable),
+    organizationMembershipRelations: getOrganizationMembershipsRelationsSchema(mysqlTable, userRelationsOverrides),
+    organizationMembershipRoles: getOrganizationMembershipRolesSchema(mysqlTable),
+    organizationMembershipRolesRelations: getOrganizationMembershipRolesRelationsSchema(mysqlTable),
+    merchantSubscription: getMerchantSubscriptionSchema(mysqlTable),
+    merchantSubscriptionRelations: getMerchantSubscriptionRelationsSchema(mysqlTable),
+    subscription: getSubscriptionSchema(mysqlTable),
+    subscriptionRelations: getSubscriptionRelationsSchema(mysqlTable),
+    profiles: getProfilesSchema(mysqlTable),
+    profilesRelations: getProfilesRelationsSchema(mysqlTable, userRelationsOverrides),
+    entitlementTypes: getEntitlementTypesSchema(mysqlTable),
+    entitlements: getEntitlementsSchema(mysqlTable),
+    entitlementsRelations: getEntitlementRelationsSchema(mysqlTable, userRelationsOverrides)
+  };
+}
+__name(getCourseBuilderSchema, "getCourseBuilderSchema");
+function createTables(mySqlTable) {
+  return getCourseBuilderSchema(mySqlTable);
+}
+__name(createTables, "createTables");
+
+export {
+  getCourseBuilderSchema,
+  createTables
+};
+//# sourceMappingURL=chunk-TNH2C27F.js.map