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

package/src/lib/mysql/ports/content-resource.ts

@@ -0,0 +1,442 @@
+import { and, asc, eq, or, sql } from 'drizzle-orm'
+
+import type { ContentResourcePort } from '@coursebuilder/core/ports'
+import {
+	ContentResourceResourceSchema,
+	ContentResourceSchema,
+	type ContentResource,
+} from '@coursebuilder/core/schemas/content-resource-schema'
+import { VideoResourceSchema } from '@coursebuilder/core/schemas/video-resource'
+import { logger as baseLogger } from '@coursebuilder/utils/logger'
+
+import type { MySqlContext } from '../context.js'
+
+type OrdinaryContentResourcePort = Omit<
+	ContentResourcePort,
+	'createEvent' | 'createEventSeries' | 'createCohort' | 'createWorkshop'
+>
+
+function toError(error: unknown) {
+	return error instanceof Error ? error : new Error(String(error))
+}
+
+const logger = baseLogger as unknown as {
+	error: (error: Error, attrs?: Record<string, unknown>) => void
+	debug: (message: string, attrs?: Record<string, unknown>) => void
+}
+
+/**
+ * Creates the MySQL implementation of ordinary content resource persistence.
+ *
+ * @param context - The shared MySQL client and table set.
+ * @returns The eight content resource operations without composition creators.
+ *
+ * @example
+ * ```ts
+ * const contentResourcePort = createContentResourcePort(context)
+ * ```
+ */
+export function createContentResourcePort({
+	client,
+	tables,
+}: MySqlContext): OrdinaryContentResourcePort {
+	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: any) => {
+					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: string,
+		): Promise<ContentResource | null> {
+			if (!videoResourceId) {
+				return null
+			}
+
+			// Use a SQL query to find the parent post or lesson of this video resource
+			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
+			}
+
+			// Fetch the full resource with relationships
+			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: string,
+			options?: {
+				withResources?: boolean
+				withTags?: boolean
+				withProducts?: boolean
+				withPricing?: boolean
+			},
+		): Promise<ContentResource | null> {
+			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
+		},
+	}
+}