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

package/dist/chunk-LWEKWDLC.js

@@ -0,0 +1,300 @@
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/ports/content-resource.ts
+import { and, asc, eq, or, sql } from "drizzle-orm";
+import { ContentResourceResourceSchema, ContentResourceSchema } from "@coursebuilder/core/schemas/content-resource-schema";
+import { VideoResourceSchema } from "@coursebuilder/core/schemas/video-resource";
+import { logger as baseLogger } from "@coursebuilder/utils/logger";
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+__name(toError, "toError");
+var logger = baseLogger;
+function createContentResourcePort({ client, tables }) {
+  const { contentResource, contentResourceResource, contentResourceTag } = tables;
+  return {
+    addResourceToResource: async function(options) {
+      const { parentResourceId, childResourceId } = options;
+      const parentResourceData = await client.query.contentResource.findFirst({
+        where: or(eq(sql`JSON_EXTRACT (${contentResource.fields}, "$.slug")`, parentResourceId), eq(contentResource.id, parentResourceId)),
+        with: {
+          resources: true
+        }
+      });
+      const parsedParentResource = ContentResourceSchema.safeParse(parentResourceData);
+      if (!parsedParentResource.success) {
+        return null;
+      }
+      const parentResource = parsedParentResource.data;
+      await client.insert(contentResourceResource).values({
+        resourceOfId: parentResource.id,
+        resourceId: childResourceId,
+        position: parentResource.resources?.length || 0
+      });
+      const resourceJoin = await client.query.contentResourceResource.findFirst({
+        where: and(eq(contentResourceResource.resourceOfId, parentResource.id), eq(contentResourceResource.resourceId, childResourceId)),
+        with: {
+          resource: true
+        }
+      });
+      const parsedResourceJoin = ContentResourceResourceSchema.safeParse(resourceJoin);
+      if (!parsedResourceJoin.success) {
+        return null;
+      }
+      return parsedResourceJoin.data;
+    },
+    async removeResourceFromResource(options) {
+      const { childResourceId, parentResourceId } = options;
+      const parentResourceData = await client.query.contentResource.findFirst({
+        where: or(eq(sql`JSON_EXTRACT (${contentResource.fields}, "$.slug")`, parentResourceId), eq(contentResource.id, parentResourceId))
+      });
+      const parsedParentResource = ContentResourceSchema.safeParse(parentResourceData);
+      if (!parsedParentResource.success) {
+        return null;
+      }
+      const parentResource = parsedParentResource.data;
+      const resourceJoin = await client.query.contentResourceResource.findFirst({
+        where: and(eq(contentResourceResource.resourceOfId, parentResource.id), eq(contentResourceResource.resourceId, childResourceId)),
+        with: {
+          resource: true
+        }
+      });
+      const parsedResourceJoin = ContentResourceResourceSchema.safeParse(resourceJoin);
+      if (!parsedResourceJoin.success) {
+        return null;
+      }
+      await client.delete(contentResourceResource).where(and(eq(contentResourceResource.resourceOfId, parentResource.id), eq(contentResourceResource.resourceId, childResourceId)));
+      return parsedResourceJoin.data.resource;
+    },
+    async updateContentResourceFields(options) {
+      if (!options.id) {
+        throw new Error("No content resource id.");
+      }
+      const currentResource = await client.select().from(contentResource).where(eq(contentResource.id, options.id)).then((res) => res[0]);
+      await client.update(contentResource).set({
+        fields: {
+          ...currentResource.fields,
+          ...options.fields
+        }
+      }).where(eq(contentResource.id, options.id));
+      const resource = await client.query.contentResource.findFirst({
+        where: eq(contentResource.id, options.id),
+        with: {
+          resources: {
+            with: {
+              resource: {
+                with: {
+                  resources: {
+                    with: {
+                      resource: true
+                    },
+                    orderBy: asc(contentResourceResource.position)
+                  }
+                }
+              }
+            },
+            orderBy: asc(contentResourceResource.position)
+          }
+        }
+      });
+      const parsedResource = ContentResourceSchema.safeParse(resource);
+      if (!parsedResource.success) {
+        logger.error(parsedResource.error, {
+          event: "adapter.contentResource.parse_failed",
+          resourceId: options.id
+        });
+        return null;
+      }
+      return parsedResource.data;
+    },
+    async getVideoResource(id) {
+      if (!id) {
+        return null;
+      }
+      const query = sql`
+    SELECT
+      id as id,
+      CAST(updatedAt AS DATETIME) as updatedAt,
+      CAST(createdAt AS DATETIME) as createdAt,
+      JSON_EXTRACT (${contentResource.fields}, "$.state") AS state,
+      JSON_EXTRACT (${contentResource.fields}, "$.duration") AS duration,
+      JSON_UNQUOTE(JSON_EXTRACT (${contentResource.fields}, "$.resolution")) AS resolution,
+      JSON_EXTRACT (${contentResource.fields}, "$.muxPlaybackId") AS muxPlaybackId,
+      JSON_EXTRACT (${contentResource.fields}, "$.muxAssetId") AS muxAssetId,
+      JSON_EXTRACT (${contentResource.fields}, "$.transcript") AS transcript,
+      JSON_EXTRACT (${contentResource.fields}, "$.chapters") AS chapters
+    FROM
+      ${contentResource}
+    WHERE
+      type = 'videoResource'
+      AND (id = ${id});
+
+ `;
+      return client.execute(query).then((result) => {
+        const rows = Array.isArray(result) ? result[0] : result.rows;
+        const parsedResource = VideoResourceSchema.safeParse(rows?.[0]);
+        return parsedResource.success ? parsedResource.data : null;
+      }).catch((error) => {
+        logger.error(toError(error), {
+          event: "adapter.videoResource.lookup.failed",
+          resourceId: id
+        });
+        throw error;
+      });
+    },
+    async getParentResourceOfVideoResource(videoResourceId) {
+      if (!videoResourceId) {
+        return null;
+      }
+      const results = await client.select().from(contentResource).innerJoin(contentResourceResource, eq(contentResourceResource.resourceOfId, contentResource.id)).where(and(eq(contentResourceResource.resourceId, videoResourceId), or(eq(contentResource.type, "post"), eq(contentResource.type, "lesson")))).limit(1);
+      if (!results || results.length === 0) {
+        return null;
+      }
+      const resourceData = results[0]?.ContentResource;
+      if (!resourceData) {
+        return null;
+      }
+      const fullResource = await client.query.contentResource.findFirst({
+        where: eq(contentResource.id, resourceData.id),
+        with: {
+          resources: true
+        }
+      });
+      if (!fullResource) {
+        return null;
+      }
+      return ContentResourceSchema.parse(fullResource);
+    },
+    async createContentResource(data) {
+      const id = data.id || crypto.randomUUID();
+      await client.insert(contentResource).values({
+        ...data,
+        id
+      });
+      const resource = await client.query.contentResource.findFirst({
+        where: eq(contentResource.id, id),
+        with: {
+          resources: {
+            with: {
+              resource: {
+                with: {
+                  resources: {
+                    with: {
+                      resource: true
+                    },
+                    orderBy: asc(contentResourceResource.position)
+                  }
+                }
+              }
+            },
+            orderBy: asc(contentResourceResource.position)
+          }
+        }
+      });
+      const parsedResource = ContentResourceSchema.safeParse(resource);
+      if (!parsedResource.success) {
+        logger.error(parsedResource.error, {
+          event: "adapter.contentResource.parse_failed",
+          resourceId: id,
+          resourceType: data.type
+        });
+        throw new Error("Error parsing resource");
+      }
+      return parsedResource.data;
+    },
+    async getContentResource(data) {
+      const resource = await client.query.contentResource.findFirst({
+        where: or(eq(contentResource.id, data), eq(sql`JSON_EXTRACT (${contentResource.fields}, "$.slug")`, `${data}`)),
+        with: {
+          resources: {
+            with: {
+              resource: {
+                with: {
+                  resources: {
+                    with: {
+                      resource: {
+                        with: {
+                          resources: {
+                            with: {
+                              resource: true
+                            }
+                          }
+                        }
+                      }
+                    },
+                    orderBy: asc(contentResourceResource.position)
+                  }
+                }
+              }
+            },
+            orderBy: asc(contentResourceResource.position)
+          }
+        }
+      });
+      const parsedResource = ContentResourceSchema.safeParse(resource);
+      if (!parsedResource.success) {
+        logger.error(parsedResource.error, {
+          event: "adapter.contentResource.parse_failed",
+          resourceId: resource?.id,
+          resourceIdOrSlug: data
+        });
+        return null;
+      }
+      return parsedResource.data;
+    },
+    async getEvent(eventIdOrSlug, options) {
+      const { withResources = false, withTags = false, withProducts = false, withPricing = false } = options || {};
+      const eventQuery = await client.query.contentResource.findFirst({
+        where: and(or(eq(contentResource.type, "event"), eq(contentResource.type, "event-series")), or(eq(contentResource.id, eventIdOrSlug), eq(sql`JSON_EXTRACT (${contentResource.fields}, "$.slug")`, eventIdOrSlug))),
+        with: {
+          ...withResources && {
+            resources: {
+              with: {
+                resource: true
+              },
+              orderBy: asc(contentResourceResource.position)
+            }
+          },
+          ...withTags && {
+            tags: {
+              with: {
+                tag: true
+              },
+              orderBy: asc(contentResourceTag.position)
+            }
+          },
+          ...withProducts && {
+            resourceProducts: {
+              with: {
+                product: {
+                  ...withPricing && {
+                    with: {
+                      price: true
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      });
+      const parsedEvent = ContentResourceSchema.safeParse(eventQuery);
+      if (!parsedEvent.success) {
+        logger.debug("Error parsing event", {
+          eventQuery,
+          error: parsedEvent.error
+        });
+        return null;
+      }
+      return parsedEvent.data;
+    }
+  };
+}
+__name(createContentResourcePort, "createContentResourcePort");
+
+export {
+  createContentResourcePort
+};
+//# sourceMappingURL=chunk-LWEKWDLC.js.map

package/dist/chunk-OJPEBGGE.js

@@ -0,0 +1,139 @@
+import {
+  createWorkshopWorkflow
+} from "./chunk-FYT7RTVW.js";
+import {
+  createRedeemFullPriceCouponWorkflow
+} from "./chunk-5FLS4ZBX.js";
+import {
+  createTransferPurchaseToUserWorkflow
+} from "./chunk-4VZJQAPV.js";
+import {
+  createProgressPort
+} from "./chunk-W3ILNMLD.js";
+import {
+  createPurchasePort
+} from "./chunk-QO3QE3LE.js";
+import {
+  createSubscriptionPort
+} from "./chunk-CN3FCRLR.js";
+import {
+  createCohortWorkflow
+} from "./chunk-AIDM2CH6.js";
+import {
+  createEventSeriesWorkflow
+} from "./chunk-EDDG2YFS.js";
+import {
+  createEventWorkflow
+} from "./chunk-VBEXYQ6L.js";
+import {
+  createMerchantChargeAndPurchaseWorkflow
+} from "./chunk-EDKWCMA7.js";
+import {
+  createAuthStoragePort
+} from "./chunk-AZY2VRAE.js";
+import {
+  createCatalogPort
+} from "./chunk-QQKNNFFB.js";
+import {
+  createContentResourcePort
+} from "./chunk-LWEKWDLC.js";
+import {
+  createCouponPort
+} from "./chunk-EAXC4CQD.js";
+import {
+  createEntitlementPort
+} from "./chunk-WJ2ZUXL3.js";
+import {
+  createIdentityPort
+} from "./chunk-TNWNW666.js";
+import {
+  createMerchantPort
+} from "./chunk-ALTODDUX.js";
+import {
+  createOrganizationPort
+} from "./chunk-5YR5M22S.js";
+import {
+  createMySqlContext
+} from "./chunk-RBHCV3UW.js";
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/index.ts
+import { mysqlTable as defaultMySqlTableFn } from "drizzle-orm/mysql-core";
+function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn, paymentProvider) {
+  const context = createMySqlContext(client, tableFn);
+  const organizationPort = createOrganizationPort(context);
+  const catalogPort = createCatalogPort(context, paymentProvider);
+  const contentResourcePort = createContentResourcePort(context);
+  const couponPort = createCouponPort(context);
+  const entitlementPort = createEntitlementPort(context);
+  const identityPort = createIdentityPort(context);
+  const merchantPort = createMerchantPort(context);
+  const subscriptionPort = createSubscriptionPort(context);
+  const authStoragePort = createAuthStoragePort(context);
+  const progressPort = createProgressPort(context);
+  const purchasePort = createPurchasePort(context);
+  const merchantChargeAndPurchaseWorkflow = createMerchantChargeAndPurchaseWorkflow(context);
+  const transferPurchaseToUserWorkflow = createTransferPurchaseToUserWorkflow(context, paymentProvider, {
+    getPurchaseUserTransferById: purchasePort.getPurchaseUserTransferById
+  });
+  const redeemFullPriceCouponWorkflow = createRedeemFullPriceCouponWorkflow(context, {
+    getCouponWithBulkPurchases: couponPort.getCouponWithBulkPurchases,
+    incrementCouponUsedCount: couponPort.incrementCouponUsedCount,
+    findOrCreateUser: identityPort.findOrCreateUser,
+    getUserById: identityPort.getUserById,
+    getMembershipsForUser: organizationPort.getMembershipsForUser,
+    createPurchase: purchasePort.createPurchase,
+    createPurchaseTransfer: purchasePort.createPurchaseTransfer,
+    getExistingNonBulkValidPurchasesOfProduct: purchasePort.getExistingNonBulkValidPurchasesOfProduct,
+    getPurchase: purchasePort.getPurchase
+  });
+  const createEventWorkflowOperations = createEventWorkflow(context, {
+    getEvent: contentResourcePort.getEvent,
+    addResourceToProduct: catalogPort.addResourceToProduct,
+    createProduct: catalogPort.createProduct,
+    createCoupon: couponPort.createCoupon
+  });
+  const createEventSeriesWorkflowOperations = createEventSeriesWorkflow(context, {
+    addResourceToProduct: catalogPort.addResourceToProduct,
+    createProduct: catalogPort.createProduct,
+    createCoupon: couponPort.createCoupon
+  });
+  const createCohortWorkflowOperations = createCohortWorkflow(context, {
+    createProduct: catalogPort.createProduct,
+    createCoupon: couponPort.createCoupon
+  });
+  const createWorkshopWorkflowOperations = createWorkshopWorkflow(context, {
+    createProduct: catalogPort.createProduct,
+    createCoupon: couponPort.createCoupon
+  });
+  const adapter = {
+    client,
+    ...redeemFullPriceCouponWorkflow,
+    ...purchasePort,
+    ...merchantChargeAndPurchaseWorkflow,
+    ...transferPurchaseToUserWorkflow,
+    ...contentResourcePort,
+    ...createEventWorkflowOperations,
+    ...createEventSeriesWorkflowOperations,
+    ...createCohortWorkflowOperations,
+    ...createWorkshopWorkflowOperations,
+    ...identityPort,
+    ...authStoragePort,
+    ...organizationPort,
+    ...catalogPort,
+    ...couponPort,
+    ...entitlementPort,
+    ...merchantPort,
+    ...progressPort,
+    ...subscriptionPort
+  };
+  return adapter;
+}
+__name(mySqlDrizzleAdapter, "mySqlDrizzleAdapter");
+
+export {
+  mySqlDrizzleAdapter
+};
+//# sourceMappingURL=chunk-OJPEBGGE.js.map