@coursebuilder/adapter-drizzle 2.0.0 → 2.1.0

package/src/lib/mysql/cms-resource-actions.ts

@@ -0,0 +1,490 @@
+import {
+	and,
+	asc,
+	desc,
+	eq,
+	inArray,
+	isNull,
+	notInArray,
+	sql,
+} from 'drizzle-orm'
+import { MySqlDatabase, MySqlTableFn } from 'drizzle-orm/mysql-core'
+import { z } from 'zod'
+
+import { getContentResourceProductSchema } from './schemas/content/content-resource-product.js'
+import { getContentResourceResourceSchema } from './schemas/content/content-resource-resource.js'
+import { getContentResourceSchema } from './schemas/content/content-resource.js'
+
+/**
+ * Shared CMS-editor query implementations (ai-hero `resources-query.ts`
+ * lineage) behind every app's `src/lib/cms/resource-actions.ts` server-action
+ * module: the ONE recent-first picker query powering every add-surface, the
+ * video-library picker, the post → list membership seed, and the reverse
+ * parent lookup behind the "Part of" strip.
+ *
+ * This is a FACTORY, not a server-action module: `'use server'` exports must
+ * live in each app (they bind to the app bundle), so apps instantiate this
+ * with their db/auth and re-export thin `'use server'` wrappers with
+ * identical signatures.
+ */
+
+type ContentResourceTable = ReturnType<typeof getContentResourceSchema>
+type ContentResourceResourceTable = ReturnType<
+	typeof getContentResourceResourceSchema
+>
+type ContentResourceProductTable = ReturnType<
+	typeof getContentResourceProductSchema
+>
+
+/** Minimal session+ability surface the actions gate on. */
+export interface CmsAuthContext {
+	session: { user?: unknown | null } | null
+	// `any` params on purpose — CASL abilities type `can` with app-specific
+	// Actions/Subjects unions, which would otherwise fail contravariance.
+	ability: { can: (action: any, subject: any) => boolean }
+}
+
+/** Row shape for the ResourcePicker (mirrors `PickerItem` in the ui kit). */
+export interface CmsPickerItem {
+	id: string
+	type: string
+	title: string
+	slug?: string
+	state?: string
+	updatedAt?: string | Date
+	detail?: string
+	thumbnailUrl?: string
+}
+
+/** Row shape for the "Part of" strip (mirrors `ResourceParent` in the ui kit). */
+export interface CmsResourceParent {
+	id: string
+	type: string
+	title: string
+	href: string
+	detail?: string
+}
+
+/** Row shape for the post editor's lists field (mirrors `ListMembership`). */
+export interface CmsListMembership {
+	listId: string
+	title: string
+	slug?: string
+	href?: string
+	position: number
+}
+
+/** Lean video-library row for the body editor's "Video…" picker. */
+export interface VideoPickerRow {
+	id: string
+	title: string
+	state: string
+	thumbnailUrl?: string
+	duration: number | null
+	createdAt: Date | null
+}
+
+/** Row shape for the Media tab's image grid (mirrors `ImageLibraryRow` in the ui kit, plus `id`). */
+const CmsImageResourceRowSchema = z.object({
+	id: z.string(),
+	url: z.string(),
+	alt: z.string().optional().nullable(),
+	// Row creation time — the media tab's unified grid sorts by it.
+	createdAt: z.coerce.date().optional().nullable(),
+})
+
+export type CmsImageResourceRow = z.infer<typeof CmsImageResourceRowSchema>
+
+const ListResourcesForPickerInputSchema = z.object({
+	types: z.array(z.string()).min(1),
+	search: z.string().trim().max(200).optional(),
+	excludeIds: z.array(z.string()).default([]),
+	limit: z.number().int().min(1).max(100).default(20),
+})
+
+export type ListResourcesForPickerInput = z.input<
+	typeof ListResourcesForPickerInputSchema
+>
+
+export interface CreateCmsResourceActionsOptions {
+	/**
+	 * The app's drizzle client. Loosely typed on purpose — each app's client
+	 * carries its own full-schema generic, but the relational keys used here
+	 * (`contentResourceResource`, `contentResourceProduct`) are guaranteed by
+	 * `getCourseBuilderSchema`.
+	 */
+	db: InstanceType<typeof MySqlDatabase>
+	contentResource: ContentResourceTable
+	contentResourceResource: ContentResourceResourceTable
+	contentResourceProduct: ContentResourceProductTable
+	/** The app's session+ability getter (e.g. `getServerAuthSession`). */
+	getAuthContext: () => Promise<CmsAuthContext>
+	/**
+	 * App route registry for parent edit links — apps with the shared
+	 * resource-paths registry pass `(type, slug) => getResourcePath(type,
+	 * slug, 'edit')`; apps without one pass their own switch.
+	 */
+	getEditHref: (type: string, slug: string) => string
+}
+
+export function createCmsResourceActions(
+	options: CreateCmsResourceActionsOptions,
+) {
+	const {
+		db,
+		contentResource,
+		contentResourceResource,
+		contentResourceProduct,
+		getAuthContext,
+		getEditHref,
+	} = options
+	// The relational API is untyped through the loose `db` param — the keys
+	// exist on every `getCourseBuilderSchema` client.
+	const dbQuery = (db as any).query
+
+	async function assertCanUpdateContent() {
+		const { session, ability } = await getAuthContext()
+		// 'update' (not 'create'): picking an existing resource to attach is an
+		// update to the parent — consistent with every other binding gate here.
+		if (!session?.user || !ability.can('update', 'Content')) {
+			throw new Error('Unauthorized')
+		}
+	}
+
+	/**
+	 * Recent-first, DB-backed resource query for the editor's ResourcePicker —
+	 * ONE query powering every add-surface. `ORDER BY updatedAt DESC` so
+	 * recently-touched resources surface first; optional title substring
+	 * search as a secondary path (TypeSense remains the primary site search
+	 * surface and is untouched). Lean select — no bodies shipped to the
+	 * client.
+	 */
+	async function listResourcesForPicker(
+		input: ListResourcesForPickerInput,
+	): Promise<CmsPickerItem[]> {
+		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) {
+			// MySQL LIKE is case-insensitive under the default collation;
+			// escape LIKE metacharacters so user input matches literally.
+			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<
+					string | null
+				>`JSON_UNQUOTE(JSON_EXTRACT(${contentResource.fields}, '$.title'))`,
+				// Generated (indexed) column — cheaper than a JSON_EXTRACT here.
+				slug: contentResource.slug,
+				state: sql<
+					string | null
+				>`JSON_UNQUOTE(JSON_EXTRACT(${contentResource.fields}, '$.state'))`,
+				postType: sql<
+					string | null
+				>`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 ?? undefined,
+			updatedAt: row.updatedAt ?? undefined,
+		}))
+	}
+
+	/**
+	 * Recent-first video library for the body editor's "Video…" insert.
+	 *
+	 * A sibling of `listResourcesForPicker` because videoResources don't fit
+	 * its shape: they have no `fields.title`/slug (the id IS the upload
+	 * filename, so search matches the id), their `fields.state` is a video
+	 * lifecycle ('processing'/'ready'/…) rather than editorial, and picker
+	 * rows want the Mux poster + duration. Same auth gate; newest-first by
+	 * `createdAt` (uploads don't get edited, they get created).
+	 */
+	async function listVideoResourcesForPicker(input: {
+		search?: string
+		excludeIds?: string[]
+		limit?: number
+		offset?: number
+	}): Promise<VideoPickerRow[]> {
+		await assertCanUpdateContent()
+
+		const excludeIds = input.excludeIds ?? []
+		// The Media tab pages by offset ('Load more' appends the next page) —
+		// `limit` is a per-page clamp, not a total ceiling; picker popovers
+		// still default to 20 with no offset.
+		const limit = Math.min(Math.max(input.limit ?? 20, 1), 200)
+		const offset = Math.max(0, Math.floor(input.offset ?? 0))
+
+		// JSON-free conditions ONLY: even an id-only sorted query hits Vitess's
+		// "Out of sort memory" (errno 1038) when the WHERE computes JSON_EXTRACT
+		// over a large library — the lifecycle-state filter moves to app code
+		// below (with over-fetch so the page still fills).
+		const conditions = [
+			eq(contentResource.type, 'videoResource'),
+			isNull(contentResource.deletedAt),
+		]
+		if (excludeIds.length > 0) {
+			conditions.push(notInArray(contentResource.id, excludeIds))
+		}
+		if (input.search) {
+			// Escape LIKE metacharacters so user input matches literally.
+			const escaped = input.search.replace(/[\\%_]/g, '\\$&')
+			conditions.push(sql`${contentResource.id} LIKE ${`%${escaped}%`}`)
+		}
+
+		// Two-step on purpose: ORDER BY over rows that also compute
+		// JSON_EXTRACTs blows MySQL's sort buffer on large libraries ("Out of
+		// sort memory", errno 1038 on PlanetScale) — so sort/limit a minimal
+		// id+createdAt page first, then pull the JSON fields for just that page.
+		const pageRows = await db
+			.select({ id: contentResource.id, createdAt: contentResource.createdAt })
+			.from(contentResource)
+			.where(and(...conditions))
+			.orderBy(desc(contentResource.createdAt))
+			// The lifecycle-state filter is app-side, so `offset` must apply
+			// AFTER filtering — fetch the requested page's whole filtered prefix
+			// (the detail lookup below stays a sort-free IN(), safe for Vitess)
+			// and slice. Over-fetch: the state filter below may drop rows.
+			.limit(offset + limit + 50)
+		if (pageRows.length === 0) return []
+
+		const detailRows = await db
+			.select({
+				id: contentResource.id,
+				state: sql<
+					string | null
+				>`JSON_UNQUOTE(JSON_EXTRACT(${contentResource.fields}, '$.state'))`,
+				muxPlaybackId: sql<
+					string | null
+				>`JSON_UNQUOTE(JSON_EXTRACT(${contentResource.fields}, '$.muxPlaybackId'))`,
+				duration: sql<
+					number | string | null
+				>`JSON_EXTRACT(${contentResource.fields}, '$.duration')`,
+				createdAt: contentResource.createdAt,
+			})
+			.from(contentResource)
+			.where(
+				inArray(
+					contentResource.id,
+					pageRows.map((row) => row.id),
+				),
+			)
+		// Re-impose the page order — the IN() fetch returns rows unordered.
+		const byId = new Map(detailRows.map((row) => [row.id, row]))
+		const rows = pageRows
+			.flatMap((page) => byId.get(page.id) ?? [])
+			// Hide unusable videos; keep processing ones (attach works
+			// mid-process).
+			.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`
+				: undefined,
+			duration: row.duration != null ? Number(row.duration) : null,
+			createdAt: row.createdAt,
+		}))
+	}
+
+	/**
+	 * Newest-first image page for the media library. `limit` is a PER-PAGE
+	 * clamp (200 — same ceiling as the video picker query, not a total cap);
+	 * `offset` (default 0) pages past it — the Media tab's "Load more"
+	 * fetches the next offset page and appends.
+	 *
+	 * Deliberately UNGATED (unlike the sibling pickers): the app-side query
+	 * this replaces had no auth check — it's only reachable through the
+	 * editor's server bindings.
+	 */
+	async function listImageResources({
+		limit,
+		offset = 0,
+	}: {
+		limit: number
+		offset?: number
+	}): Promise<CmsImageResourceRow[]> {
+		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<
+					string | null
+				>`JSON_UNQUOTE(JSON_EXTRACT(${contentResource.fields}, '$.url'))`,
+				alt: sql<
+					string | null
+				>`JSON_UNQUOTE(JSON_EXTRACT(${contentResource.fields}, '$.alt'))`,
+				createdAt: contentResource.createdAt,
+			})
+			.from(contentResource)
+			.where(eq(contentResource.type, 'imageResource'))
+			.orderBy(desc(contentResource.createdAt))
+			.limit(capped)
+			.offset(skip)
+
+		// Same all-or-nothing guard the app-side query had: a malformed row
+		// (e.g. missing `fields.url`) fails the whole page closed to [].
+		const parsed = z.array(CmsImageResourceRowSchema).safeParse(rows)
+		return parsed.success ? parsed.data : []
+	}
+
+	/**
+	 * Lists a post belongs to — the seed for the post editor's
+	 * `{ kind: 'lists' }` membership field (ai-hero `getPostLists`
+	 * equivalent; the legacy `getListForPost` returned only the oldest
+	 * PUBLISHED list, which would hide draft-list memberships from editors).
+	 * Reverse join-row lookup, list parents only.
+	 */
+	async function getPostListMemberships(
+		postId: string,
+	): Promise<CmsListMembership[]> {
+		await assertCanUpdateContent()
+
+		const links = await dbQuery.contentResourceResource.findMany({
+			where: and(
+				eq(contentResourceResource.resourceId, postId),
+				isNull(contentResourceResource.deletedAt),
+			),
+			with: { resourceOf: true },
+		})
+
+		return links
+			.filter(
+				(link: any) =>
+					link.resourceOf?.type === 'list' && !link.resourceOf.deletedAt,
+			)
+			.map((link: any) => {
+				const fields = (link.resourceOf.fields ?? {}) as Record<string, any>
+				return {
+					listId: link.resourceOf.id,
+					title: fields.title ?? fields.slug ?? link.resourceOf.id,
+					slug: fields.slug ?? undefined,
+					href: fields.slug ? getEditHref('list', fields.slug) : undefined,
+					position: link.position,
+				}
+			})
+	}
+
+	/**
+	 * One-level reverse lookup: every resource this resource is directly part
+	 * of. Covers both membership mechanisms:
+	 * - `ContentResourceResource` (child → parent via `resourceOf`): post ∈
+	 *   list, lesson ∈ workshop/section, workshop ∈ cohort, event ∈
+	 *   event-series
+	 * - `ContentResourceProduct`: cohort/workshop/event ∈ product
+	 *
+	 * Powers the "Part of" strip; `href` is the parent's EDIT path.
+	 */
+	async function getResourceParents(
+		resourceId: string,
+	): Promise<CmsResourceParent[]> {
+		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: CmsResourceParent[] = []
+
+		for (const link of containerLinks) {
+			const parent = link.resourceOf
+			if (!parent || parent.deletedAt) continue
+			// videoResource attachments etc. aren't "parents" in the strip's
+			// sense — only container types with real edit surfaces qualify.
+			if (parent.type === 'videoResource') continue
+			const slug: string = parent.fields?.slug ?? ''
+			const siblings = parent.resources ?? []
+			const index = siblings.findIndex(
+				(sibling: any) => 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: string = 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
+	}
+
+	return {
+		listResourcesForPicker,
+		listVideoResourcesForPicker,
+		listImageResources,
+		getPostListMemberships,
+		getResourceParents,
+	}
+}

package/src/lib/mysql/index.ts

@@ -250,6 +250,8 @@ import {
 	getOrganizationsSchema,
 } from './schemas/org/organizations.js'
 
+export * from './cms-resource-actions.js'
+
 export const guid = customAlphabet('1234567890abcdefghijklmnopqrstuvwxyz', 5)
 
 export const normalizeExpirationDate = (date: Date | undefined) => {