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

package/dist/chunk-ALTODDUX.js

@@ -0,0 +1,173 @@
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/ports/merchant.ts
+import { and, desc, eq } from "drizzle-orm";
+import { v4 } from "uuid";
+import { merchantChargeSchema, merchantEventsSchema, merchantPriceSchema, merchantProductSchema } from "@coursebuilder/core/schemas";
+import { merchantAccountSchema } from "@coursebuilder/core/schemas/merchant-account-schema";
+import { merchantCustomerSchema } from "@coursebuilder/core/schemas/merchant-customer-schema";
+import { MerchantSessionSchema } from "@coursebuilder/core/schemas/merchant-session";
+import { MerchantSubscriptionSchema } from "@coursebuilder/core/schemas/merchant-subscription";
+import { logger as baseLogger } from "@coursebuilder/utils/logger";
+var logger = baseLogger;
+function createMerchantPort({ client, tables }) {
+  const { merchantAccount, merchantCharge, merchantCustomer, merchantEvents, merchantPrice, merchantProduct, merchantSession, merchantSubscription: merchantSubscriptionTable } = tables;
+  const merchantPort = {
+    createMerchantCustomer: async (options) => {
+      await client.insert(merchantCustomer).values({
+        id: `mc_${v4()}`,
+        identifier: options.identifier,
+        merchantAccountId: options.merchantAccountId,
+        userId: options.userId,
+        status: 1
+      });
+      return merchantCustomerSchema.parse(await client.query.merchantCustomer.findFirst({
+        where: eq(merchantCustomer.identifier, options.identifier)
+      }));
+    },
+    getMerchantAccount: async (options) => {
+      return merchantAccountSchema.parse(await client.query.merchantAccount.findFirst({
+        where: eq(merchantAccount.label, options.provider)
+      }));
+    },
+    getMerchantPriceForProductId: async (productId) => {
+      const merchantPriceData = await client.query.merchantPrice.findFirst({
+        where: and(eq(merchantPrice.merchantProductId, productId), eq(merchantPrice.status, 1))
+      });
+      const parsedMerchantPrice = merchantPriceSchema.safeParse(merchantPriceData);
+      if (!parsedMerchantPrice.success) {
+        logger.error(parsedMerchantPrice.error, {
+          event: "adapter.merchantPrice.parse_failed",
+          productId
+        });
+        return null;
+      }
+      return parsedMerchantPrice.data;
+    },
+    getMerchantProductForProductId: async (productId) => {
+      const merchantProductData = await client.query.merchantProduct.findFirst({
+        where: eq(merchantProduct.productId, productId)
+      });
+      if (!merchantProductData)
+        return null;
+      return merchantProductSchema.parse(merchantProductData);
+    },
+    getMerchantCustomerForUserId: async (userId) => {
+      const merchantCustomerData = await client.query.merchantCustomer.findFirst({
+        where: eq(merchantCustomer.userId, userId)
+      });
+      if (!merchantCustomerData)
+        return null;
+      return merchantCustomerSchema.parse(merchantCustomerData);
+    },
+    async createMerchantSession(options) {
+      const id = `ms_${v4()}`;
+      await client.insert(merchantSession).values({
+        id,
+        identifier: options.identifier,
+        merchantAccountId: options.merchantAccountId,
+        ...options.organizationId ? {
+          organizationId: options.organizationId
+        } : {}
+      });
+      return MerchantSessionSchema.parse(await client.query.merchantSession.findFirst({
+        where: eq(merchantSession.id, id)
+      }));
+    },
+    async findOrCreateMerchantCustomer(options) {
+      const merchantCustomer2 = merchantCustomerSchema.nullable().optional().parse(await client.query.merchantCustomer.findFirst({
+        where: (merchantCustomer3, { eq: eq2 }) => eq2(merchantCustomer3.identifier, options.identifier)
+      }));
+      if (merchantCustomer2) {
+        return merchantCustomer2;
+      }
+      return await merchantPort.createMerchantCustomer({
+        identifier: options.identifier,
+        merchantAccountId: options.merchantAccountId,
+        userId: options.user.id
+      });
+    },
+    async createMerchantEvent(options) {
+      const eventId = `me_${v4()}`;
+      await client.insert(merchantEvents).values({
+        id: eventId,
+        merchantAccountId: options.merchantAccountId,
+        identifier: options.identifier,
+        payload: options.payload
+      });
+      const createdEvent = await client.query.merchantEvents.findFirst({
+        where: eq(merchantEvents.id, eventId)
+      });
+      return merchantEventsSchema.parse(createdEvent);
+    },
+    async getMerchantEventByIdentifier(identifier) {
+      const event = await client.query.merchantEvents.findFirst({
+        where: eq(merchantEvents.identifier, identifier)
+      });
+      return event ? merchantEventsSchema.parse(event) : null;
+    },
+    async getMerchantEventsByAccount(merchantAccountId) {
+      const events = await client.query.merchantEvents.findMany({
+        where: eq(merchantEvents.merchantAccountId, merchantAccountId),
+        orderBy: [
+          desc(merchantEvents.createdAt)
+        ]
+      });
+      return events.map((event) => merchantEventsSchema.parse(event));
+    },
+    async getMerchantCharge(merchantChargeId) {
+      const mCharge = await client.query.merchantCharge.findFirst({
+        where: eq(merchantCharge.id, merchantChargeId)
+      });
+      const parsed = merchantChargeSchema.safeParse(mCharge);
+      if (!parsed.success) {
+        logger.error(parsed.error, {
+          event: "adapter.merchantCharge.parse_failed",
+          merchantChargeId
+        });
+        return null;
+      }
+      return parsed.data;
+    },
+    async getMerchantProduct(stripeProductId) {
+      return merchantProductSchema.nullable().parse(await client.query.merchantProduct.findFirst({
+        where: eq(merchantProduct.identifier, stripeProductId)
+      }));
+    },
+    getMerchantSubscription: async (merchantSubscriptionId) => {
+      return MerchantSubscriptionSchema.parse(await client.query.merchantSubscription.findFirst({
+        where: eq(merchantSubscriptionTable.id, merchantSubscriptionId)
+      }));
+    },
+    createMerchantSubscription: async (options) => {
+      const id = crypto.randomUUID();
+      await client.insert(merchantSubscriptionTable).values({
+        ...options,
+        id
+      });
+      return MerchantSubscriptionSchema.parse(await client.query.merchantSubscription.findFirst({
+        where: eq(merchantSubscriptionTable.id, id)
+      }));
+    },
+    updateMerchantSubscription: async (options) => {
+      await client.update(merchantSubscriptionTable).set({
+        status: Number(options.status)
+      }).where(eq(merchantSubscriptionTable.id, options.merchantSubscriptionId));
+      return MerchantSubscriptionSchema.parse(await client.query.merchantSubscription.findFirst({
+        where: eq(merchantSubscriptionTable.id, options.merchantSubscriptionId)
+      }));
+    },
+    deleteMerchantSubscription: async (merchantSubscriptionId) => {
+      await client.delete(merchantSubscriptionTable).where(eq(merchantSubscriptionTable.id, merchantSubscriptionId));
+    }
+  };
+  return merchantPort;
+}
+__name(createMerchantPort, "createMerchantPort");
+
+export {
+  createMerchantPort
+};
+//# sourceMappingURL=chunk-ALTODDUX.js.map

package/dist/chunk-AZY2VRAE.js

@@ -0,0 +1,63 @@
+import {
+  __name
+} from "./chunk-2X5XVNDN.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-AZY2VRAE.js.map

package/dist/chunk-BS7T27VL.js

@@ -0,0 +1,239 @@
+import {
+  external_exports
+} from "./chunk-QKOSV34V.js";
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/cms-resource-actions.ts
+import { and, asc, desc, eq, inArray, isNull, notInArray, sql } from "drizzle-orm";
+var jsonNumber = external_exports.preprocess((value) => value == null ? null : Number(value), external_exports.number().nullable().optional());
+var CmsImageResourceRowSchema = external_exports.object({
+  id: external_exports.string(),
+  url: external_exports.string(),
+  alt: external_exports.string().optional().nullable(),
+  // Human filename (the uploaded file's name) — the media grid prefers it
+  // over `alt` for the tile label; absent on older rows.
+  name: external_exports.string().optional().nullable(),
+  // Row creation time — the media tab's unified grid sorts by it.
+  createdAt: external_exports.coerce.date().optional().nullable(),
+  // Cloudinary metadata — optional/nullable so pre-metadata rows keep
+  // working (JSON_EXTRACT returns NULL when the key is absent). Numeric
+  // coercion preserves null (plain z.coerce.number() would turn it into 0);
+  // MySQL JSON numerics can arrive as strings through some drivers.
+  width: jsonNumber,
+  height: jsonNumber,
+  bytes: jsonNumber,
+  format: external_exports.string().optional().nullable()
+});
+var ListResourcesForPickerInputSchema = external_exports.object({
+  types: external_exports.array(external_exports.string()).min(1),
+  search: external_exports.string().trim().max(200).optional(),
+  excludeIds: external_exports.array(external_exports.string()).default([]),
+  limit: external_exports.number().int().min(1).max(100).default(20)
+});
+function createCmsResourceActions(options) {
+  const { db, contentResource, contentResourceResource, contentResourceProduct, getAuthContext, getEditHref } = options;
+  const dbQuery = db.query;
+  async function assertCanUpdateContent() {
+    const { session, ability } = await getAuthContext();
+    if (!session?.user || !ability.can("update", "Content")) {
+      throw new Error("Unauthorized");
+    }
+  }
+  __name(assertCanUpdateContent, "assertCanUpdateContent");
+  async function listResourcesForPicker(input) {
+    await assertCanUpdateContent();
+    const { types, search, excludeIds, limit } = ListResourcesForPickerInputSchema.parse(input);
+    const conditions = [
+      inArray(contentResource.type, types),
+      isNull(contentResource.deletedAt)
+    ];
+    if (excludeIds.length > 0) {
+      conditions.push(notInArray(contentResource.id, excludeIds));
+    }
+    if (search) {
+      const escaped = search.replace(/[\\%_]/g, "\\$&");
+      conditions.push(sql`JSON_UNQUOTE(JSON_EXTRACT(${contentResource.fields}, '$.title')) LIKE ${`%${escaped}%`}`);
+    }
+    const rows = await db.select({
+      id: contentResource.id,
+      type: contentResource.type,
+      title: sql`JSON_UNQUOTE(JSON_EXTRACT(${contentResource.fields}, '$.title'))`,
+      // Generated (indexed) column — cheaper than a JSON_EXTRACT here.
+      slug: contentResource.slug,
+      state: sql`JSON_UNQUOTE(JSON_EXTRACT(${contentResource.fields}, '$.state'))`,
+      postType: sql`JSON_UNQUOTE(JSON_EXTRACT(${contentResource.fields}, '$.postType'))`,
+      updatedAt: contentResource.updatedAt
+    }).from(contentResource).where(and(...conditions)).orderBy(desc(contentResource.updatedAt)).limit(limit);
+    return rows.map((row) => ({
+      id: row.id,
+      type: row.type,
+      title: row.title ?? row.slug ?? row.id,
+      slug: row.slug ?? "",
+      state: row.state ?? "draft",
+      detail: row.postType ?? void 0,
+      updatedAt: row.updatedAt ?? void 0
+    }));
+  }
+  __name(listResourcesForPicker, "listResourcesForPicker");
+  async function listVideoResourcesForPicker(input) {
+    await assertCanUpdateContent();
+    const excludeIds = input.excludeIds ?? [];
+    const limit = Math.min(Math.max(input.limit ?? 20, 1), 200);
+    const offset = Math.max(0, Math.floor(input.offset ?? 0));
+    const conditions = [
+      eq(contentResource.type, "videoResource"),
+      isNull(contentResource.deletedAt)
+    ];
+    if (excludeIds.length > 0) {
+      conditions.push(notInArray(contentResource.id, excludeIds));
+    }
+    if (input.search) {
+      const escaped = input.search.replace(/[\\%_]/g, "\\$&");
+      conditions.push(sql`${contentResource.id} LIKE ${`%${escaped}%`}`);
+    }
+    const pageRows = await db.select({
+      id: contentResource.id,
+      createdAt: contentResource.createdAt
+    }).from(contentResource).where(and(...conditions)).orderBy(desc(contentResource.createdAt)).limit(offset + limit + 50);
+    if (pageRows.length === 0)
+      return [];
+    const detailRows = await db.select({
+      id: contentResource.id,
+      state: sql`JSON_UNQUOTE(JSON_EXTRACT(${contentResource.fields}, '$.state'))`,
+      muxPlaybackId: sql`JSON_UNQUOTE(JSON_EXTRACT(${contentResource.fields}, '$.muxPlaybackId'))`,
+      duration: sql`JSON_EXTRACT(${contentResource.fields}, '$.duration')`,
+      createdAt: contentResource.createdAt
+    }).from(contentResource).where(inArray(contentResource.id, pageRows.map((row) => row.id)));
+    const byId = new Map(detailRows.map((row) => [
+      row.id,
+      row
+    ]));
+    const rows = pageRows.flatMap((page) => byId.get(page.id) ?? []).filter((row) => row.state !== "deleted" && row.state !== "errored").slice(offset, offset + limit);
+    return rows.map((row) => ({
+      id: row.id,
+      // videoResources have no title/slug — the filename-derived id is the
+      // human-readable handle.
+      title: row.id,
+      state: row.state ?? "processing",
+      thumbnailUrl: row.muxPlaybackId ? `https://image.mux.com/${row.muxPlaybackId}/thumbnail.png?width=96&height=54&fit_mode=smartcrop` : void 0,
+      duration: row.duration != null ? Number(row.duration) : null,
+      createdAt: row.createdAt
+    }));
+  }
+  __name(listVideoResourcesForPicker, "listVideoResourcesForPicker");
+  async function listImageResources({ limit, offset = 0 }) {
+    const capped = Math.min(Math.max(1, Math.floor(limit)), 200);
+    const skip = Math.max(0, Math.floor(offset));
+    const rows = await db.select({
+      id: contentResource.id,
+      url: sql`JSON_UNQUOTE(JSON_EXTRACT(${contentResource.fields}, '$.url'))`,
+      alt: sql`JSON_UNQUOTE(JSON_EXTRACT(${contentResource.fields}, '$.alt'))`,
+      name: sql`JSON_UNQUOTE(JSON_EXTRACT(${contentResource.fields}, '$.name'))`,
+      createdAt: contentResource.createdAt,
+      // Cloudinary metadata — NULL on pre-metadata rows (backfillable).
+      width: sql`JSON_EXTRACT(${contentResource.fields}, '$.width')`,
+      height: sql`JSON_EXTRACT(${contentResource.fields}, '$.height')`,
+      bytes: sql`JSON_EXTRACT(${contentResource.fields}, '$.bytes')`,
+      format: sql`JSON_UNQUOTE(JSON_EXTRACT(${contentResource.fields}, '$.format'))`
+    }).from(contentResource).where(eq(contentResource.type, "imageResource")).orderBy(desc(contentResource.createdAt)).limit(capped).offset(skip);
+    const parsed = external_exports.array(CmsImageResourceRowSchema).safeParse(rows);
+    return parsed.success ? parsed.data : [];
+  }
+  __name(listImageResources, "listImageResources");
+  async function getPostListMemberships(postId) {
+    await assertCanUpdateContent();
+    const links = await dbQuery.contentResourceResource.findMany({
+      where: and(eq(contentResourceResource.resourceId, postId), isNull(contentResourceResource.deletedAt)),
+      with: {
+        resourceOf: true
+      }
+    });
+    return links.filter((link) => link.resourceOf?.type === "list" && !link.resourceOf.deletedAt).map((link) => {
+      const fields = link.resourceOf.fields ?? {};
+      return {
+        listId: link.resourceOf.id,
+        title: fields.title ?? fields.slug ?? link.resourceOf.id,
+        slug: fields.slug ?? void 0,
+        href: fields.slug ? getEditHref("list", fields.slug) : void 0,
+        position: link.position
+      };
+    });
+  }
+  __name(getPostListMemberships, "getPostListMemberships");
+  async function getResourceParents(resourceId) {
+    await assertCanUpdateContent();
+    const [containerLinks, productLinks] = await Promise.all([
+      dbQuery.contentResourceResource.findMany({
+        where: eq(contentResourceResource.resourceId, resourceId),
+        with: {
+          resourceOf: {
+            with: {
+              // Sibling JOIN rows only (no nested resource objects) —
+              // cheap, and enough to compute this resource's ordinal.
+              resources: {
+                orderBy: asc(contentResourceResource.position)
+              }
+            }
+          }
+        }
+      }),
+      dbQuery.contentResourceProduct.findMany({
+        where: and(eq(contentResourceProduct.resourceId, resourceId), isNull(contentResourceProduct.deletedAt)),
+        with: {
+          product: true
+        }
+      })
+    ]);
+    const parents = [];
+    for (const link of containerLinks) {
+      const parent = link.resourceOf;
+      if (!parent || parent.deletedAt)
+        continue;
+      if (parent.type === "videoResource")
+        continue;
+      const slug = parent.fields?.slug ?? "";
+      const siblings = parent.resources ?? [];
+      const index = siblings.findIndex((sibling) => sibling.resourceId === resourceId);
+      parents.push({
+        id: parent.id,
+        type: parent.type,
+        title: parent.fields?.title ?? (slug || parent.id),
+        href: getEditHref(parent.type, slug || parent.id),
+        ...index !== -1 && {
+          detail: `#${index + 1} of ${siblings.length}`
+        }
+      });
+    }
+    for (const link of productLinks) {
+      const product = link.product;
+      if (!product)
+        continue;
+      const slug = product.fields?.slug ?? "";
+      parents.push({
+        id: product.id,
+        type: "product",
+        title: product.name,
+        // Products aren't in the resource-paths registries; every app's
+        // product editor lives at /products/[slug]/edit.
+        href: `/products/${slug || product.id}/edit`
+      });
+    }
+    return parents;
+  }
+  __name(getResourceParents, "getResourceParents");
+  return {
+    listResourcesForPicker,
+    listVideoResourcesForPicker,
+    listImageResources,
+    getPostListMemberships,
+    getResourceParents
+  };
+}
+__name(createCmsResourceActions, "createCmsResourceActions");
+
+export {
+  createCmsResourceActions
+};
+//# sourceMappingURL=chunk-BS7T27VL.js.map

package/dist/chunk-CN3FCRLR.js

@@ -0,0 +1,55 @@
+import {
+  __name
+} from "./chunk-2X5XVNDN.js";
+
+// src/lib/mysql/ports/subscription.ts
+import { eq } from "drizzle-orm";
+import { MerchantSubscriptionSchema } from "@coursebuilder/core/schemas/merchant-subscription";
+import { SubscriptionSchema } from "@coursebuilder/core/schemas/subscription";
+function createSubscriptionPort({ client, tables }) {
+  const { merchantSubscription: merchantSubscriptionTable, subscription: subscriptionTable } = tables;
+  return {
+    createSubscription: async (options) => {
+      const id = `sub_${crypto.randomUUID()}`;
+      await client.insert(subscriptionTable).values({
+        ...options,
+        id
+      });
+      return SubscriptionSchema.parse(await client.query.subscription.findFirst({
+        where: eq(subscriptionTable.id, id),
+        with: {
+          product: true
+        }
+      }));
+    },
+    getSubscriptionForStripeId: async (stripeSubscriptionId) => {
+      const merchantSubscriptionParsed = MerchantSubscriptionSchema.safeParse(await client.query.merchantSubscription.findFirst({
+        where: eq(merchantSubscriptionTable.identifier, stripeSubscriptionId)
+      }));
+      if (!merchantSubscriptionParsed.success) {
+        throw new Error(`No merchant subscription found for stripe id ${stripeSubscriptionId} ${merchantSubscriptionParsed.error}`);
+      }
+      const subscriptionParsed = SubscriptionSchema.safeParse(await client.query.subscription.findFirst({
+        where: eq(subscriptionTable.merchantSubscriptionId, merchantSubscriptionParsed.data.id),
+        with: {
+          product: true
+        }
+      }));
+      if (!subscriptionParsed.success) {
+        throw new Error(`No subscription found for merchant subscription ${merchantSubscriptionParsed.data.id} ${subscriptionParsed.error}`);
+      }
+      return subscriptionParsed.data;
+    },
+    updateSubscriptionStatus: async (subscriptionId, status) => {
+      await client.update(subscriptionTable).set({
+        status
+      }).where(eq(subscriptionTable.id, subscriptionId));
+    }
+  };
+}
+__name(createSubscriptionPort, "createSubscriptionPort");
+
+export {
+  createSubscriptionPort
+};
+//# sourceMappingURL=chunk-CN3FCRLR.js.map