@coursebuilder/server 0.1.0-canary.0.0c9beb2ae

package/src/actions/create-magic-link.ts

@@ -0,0 +1,78 @@
+import type { CourseBuilderEmailProvider } from '@coursebuilder/core/auth'
+import type {
+	InternalOptions,
+	RequestInternal,
+	ResponseInternal,
+} from '@coursebuilder/core/types'
+import { createVerificationUrl } from '@coursebuilder/email/send-server-email'
+
+import type { Cookie } from '../runtime/cookie'
+import { logger } from '../runtime/logger'
+
+export async function createMagicLink(
+	request: RequestInternal,
+	cookies: Cookie[],
+	options: InternalOptions,
+): Promise<ResponseInternal> {
+	if (!options.adapter) throw new Error('Adapter not found')
+	if (request.headers?.['x-skill-secret'] !== process.env.SKILL_SECRET) {
+		return { status: 401, body: 'unauthorized' }
+	}
+
+	const { email } = request.body || {}
+
+	if (!email) {
+		return { status: 400, body: 'email is required' }
+	}
+
+	const emailProvider = options.providers.find((p) => p.type === 'email')
+
+	if (!emailProvider) {
+		return { status: 400, body: 'email provider not found' }
+	}
+
+	const expiresIn = request.body?.expiresIn || request.query?.expiresIn
+
+	let expiresAt: Date | undefined = undefined
+
+	if (expiresIn) {
+		const durationInMilliseconds = expiresIn * 1000
+		expiresAt = new Date(Date.now() + durationInMilliseconds)
+	}
+
+	try {
+		const verificationDetails = await createVerificationUrl({
+			email,
+			emailProvider: emailProvider as CourseBuilderEmailProvider,
+			authOptions: options.authConfig,
+			adapter: options.adapter,
+			baseUrl: options.baseUrl,
+			expiresAt,
+		})
+		if (!verificationDetails?.url) {
+			return {
+				status: 500,
+				body: JSON.stringify({
+					error: 'Could not create verification url',
+				}),
+			}
+		}
+		return {
+			status: 200,
+			body: JSON.stringify({
+				url: verificationDetails.url,
+			}),
+		}
+	} catch (e) {
+		const error = e instanceof Error ? e : new Error(String(e))
+		logger.error(error, {
+			context: 'magic-link.create',
+			hasEmail: Boolean(email),
+			expiresIn: expiresIn ?? null,
+		})
+		return {
+			status: 500,
+			body: JSON.stringify({ error: error.message }),
+		}
+	}
+}

package/src/actions/index.ts

@@ -0,0 +1,401 @@
+import { z } from 'zod'
+
+import { processStripeWebhook } from '@coursebuilder/commerce/process-stripe-webhook'
+import type { CourseBuilderEmailProvider } from '@coursebuilder/core/auth'
+import {
+	VIDEO_SRT_READY_EVENT,
+	VIDEO_TRANSCRIPT_READY_EVENT,
+} from '@coursebuilder/core/events/video'
+import type {
+	InternalOptions,
+	RequestInternal,
+	ResponseInternal,
+} from '@coursebuilder/core/types'
+import { sendServerEmail } from '@coursebuilder/email/send-server-email'
+import {
+	srtFromTranscriptResult,
+	transcriptAsParagraphsWithTimestamps,
+	wordLevelSrtFromTranscriptResult,
+} from '@coursebuilder/video-processing/transcript-transforms'
+
+import type { Cookie } from '../runtime/cookie'
+
+const oneYear = 31556952
+
+function getConvertkitSubscriberCookie(subscriber: any): Cookie[] {
+	return subscriber
+		? [
+				{
+					name: 'ck_subscriber',
+					value: JSON.stringify(subscriber),
+					options: {
+						secure: true,
+						httpOnly: true,
+						path: '/',
+						maxAge: oneYear,
+						sameSite: 'lax',
+					},
+				},
+				{
+					name:
+						process.env.NEXT_PUBLIC_CONVERTKIT_SUBSCRIBER_KEY ||
+						'ck_subscriber_id',
+					value: subscriber.id,
+					options: {
+						secure: true,
+						httpOnly: true,
+						path: '/',
+						maxAge: oneYear,
+						sameSite: 'lax',
+					},
+				},
+			]
+		: []
+}
+
+type Subscriber = Record<string, any>
+
+function filterNullFields(obj: Subscriber): Subscriber {
+	const filteredObj: Subscriber = {}
+
+	for (const key in obj) {
+		if (obj[key] !== null) {
+			if (typeof obj[key] === 'object' && !Array.isArray(obj[key])) {
+				filteredObj[key] = filterNullFields(obj[key] as Subscriber)
+			} else {
+				filteredObj[key] = obj[key]
+			}
+		}
+	}
+
+	return filteredObj
+}
+
+export async function getUserPurchases(
+	request: RequestInternal,
+	cookies: Cookie[],
+	options: InternalOptions,
+): Promise<ResponseInternal> {
+	const client = options.adapter
+
+	const currentUser = await options.getCurrentUser?.()
+
+	if (!currentUser?.id || currentUser.id !== request.query?.userId) {
+		return {
+			status: 401,
+			body: [],
+			headers: { 'Content-Type': 'application/json' },
+			cookies,
+		}
+	}
+
+	if (!request.query?.userId)
+		return {
+			status: 200,
+			body: [],
+			headers: { 'Content-Type': 'application/json' },
+			cookies,
+		}
+
+	const purchases = await client?.getPurchasesForUser(request.query.userId)
+
+	if (!purchases) {
+		return {
+			status: 200,
+			body: [],
+			headers: { 'Content-Type': 'application/json' },
+			cookies,
+		}
+	} else {
+		return {
+			status: 200,
+			body: purchases,
+			headers: { 'Content-Type': 'application/json' },
+			cookies,
+		}
+	}
+}
+
+export async function getSubscriber(
+	options: InternalOptions<'email-list'>,
+	cookies: Cookie[],
+): Promise<ResponseInternal<any | null>> {
+	switch (options.provider.type) {
+		case 'email-list':
+			const subscriber = await options.provider.getSubscriber(
+				options.url.searchParams.get('subscriberId') ||
+					options.cookies.ck_subscriber_id ||
+					null,
+			)
+			return {
+				status: 200,
+				body: subscriber,
+				headers: { 'Content-Type': 'application/json' },
+				cookies: getConvertkitSubscriberCookie(subscriber),
+			}
+		default:
+			throw new Error('Unsupported provider')
+	}
+}
+
+export async function subscribeToList(
+	request: RequestInternal,
+	cookies: Cookie[],
+	options: InternalOptions<'email-list'>,
+): Promise<ResponseInternal<any | null>> {
+	const response: ResponseInternal<any | null> = {
+		body: null,
+		headers: { 'Content-Type': 'application/json' },
+		cookies,
+	}
+
+	switch (options.provider.type) {
+		case 'email-list':
+			const subscribeOptions = z
+				.object({
+					listId: z.union([z.number(), z.string()]).optional(),
+					listType: z.string().optional(),
+					fields: z.record(z.string(), z.any()).optional().nullable(),
+					email: z.string(),
+					name: z.string().optional().nullable(),
+				})
+				.parse(request.body)
+
+			let user = await options.adapter?.getUserByEmail(subscribeOptions.email)
+
+			if (!user) {
+				user = await options.adapter?.createUser({
+					id: crypto.randomUUID(),
+					email: subscribeOptions.email,
+					name: subscribeOptions.name,
+					emailVerified: null,
+				})
+				if (!user) throw new Error('Could not create user')
+				options.logger.debug(`created user ${user.id}`)
+			} else {
+				options.logger.debug(`found user ${user.id}`)
+			}
+
+			response.body = await options.provider.subscribeToList({
+				user,
+				listId: subscribeOptions.listId || options.provider.defaultListId,
+				fields: subscribeOptions.fields || {},
+				listType: subscribeOptions.listType || options.provider.defaultListType,
+			})
+
+			response.cookies = getConvertkitSubscriberCookie(
+				filterNullFields(response.body),
+			)
+
+			if (!user.emailVerified) {
+				const emailProvider = options.providers.find(
+					(p) => p.type === 'email',
+				) as CourseBuilderEmailProvider
+
+				if (
+					emailProvider &&
+					options.adapter &&
+					options.provider.id === 'coursebuilder'
+				) {
+					await sendServerEmail({
+						email: user.email,
+						type: 'signup',
+						callbackUrl: `${options.baseUrl}/confirmed`,
+						emailProvider,
+						authOptions: options.authConfig,
+						adapter: options.adapter,
+						baseUrl: options.baseUrl,
+					})
+				}
+			}
+	}
+
+	return response
+}
+
+export async function session(
+	options: InternalOptions,
+	cookies: Cookie[],
+): Promise<ResponseInternal<any | null>> {
+	const { callbacks, logger } = options
+
+	const response: ResponseInternal<any | null> = {
+		body: null,
+		headers: { 'Content-Type': 'application/json' },
+		cookies,
+	}
+
+	try {
+		response.body = await callbacks.session({})
+	} catch (e) {
+		logger.error(e as Error)
+	}
+
+	return response
+}
+
+export async function srt(
+	request: RequestInternal,
+	cookies: Cookie[],
+	options: InternalOptions,
+): Promise<ResponseInternal> {
+	const client = options.adapter
+
+	const resource = await client?.getContentResource(
+		request.query?.videoResourceId,
+	)
+
+	if (!resource) throw new Error('Resource not found')
+
+	return {
+		status: 200,
+		body: resource.fields?.srt,
+		headers: { 'Content-Type': 'application/text' },
+		cookies,
+	}
+}
+
+export async function webhook(
+	request: RequestInternal,
+	cookies: Cookie[],
+	options: InternalOptions<'transcription' | 'payment'>,
+): Promise<ResponseInternal> {
+	if (!options.provider) throw new Error('Provider not found')
+
+	switch (options.provider.type) {
+		case 'payment':
+			if (options.provider.id === 'stripe') {
+				await processStripeWebhook(request.body, options)
+				return Response.json('ok', { status: 200 })
+			} else {
+				throw new Error('Unsupported provider')
+			}
+
+		case 'transcription':
+			if (!request.body) throw new Error('No body')
+
+			const { results } = request.body
+
+			const videoResourceId = options.url.searchParams.get('videoResourceId')
+
+			if (!videoResourceId) throw new Error('No videoResourceId')
+
+			const videoResource =
+				await options.adapter?.getContentResource(videoResourceId)
+
+			if (!videoResource) throw new Error('No videoResource')
+
+			const rawTranscriptId = `raw-transcript-${videoResourceId}`
+
+			const existingRawTranscript =
+				await options.adapter?.getContentResource(rawTranscriptId)
+
+			if (!existingRawTranscript) {
+				await options.adapter?.createContentResource({
+					id: rawTranscriptId,
+					type: 'raw-transcript',
+					fields: {
+						deepgramResults: results,
+					},
+					createdById: videoResource.createdById,
+				})
+				await options.adapter?.addResourceToResource({
+					childResourceId: rawTranscriptId,
+					parentResourceId: videoResourceId,
+				})
+			}
+
+			const srt = srtFromTranscriptResult(results)
+			const wordLevelSrt = wordLevelSrtFromTranscriptResult(results)
+			const transcript = transcriptAsParagraphsWithTimestamps(results)
+
+			// await options.adapter?.createContentResource({
+			// 	id: `raw-transcript-${videoResourceId}`,
+			// 	type: 'raw-transcript',
+			// 	fields: {
+			// 		rawTranscript: results,
+			// 	},
+			// 	createdById: videoResource.createdById,
+			// })
+			//
+			// await options.adapter?.addResourceToResource({
+			// 	childResourceId: `transcript-${videoResourceId}`,
+			// 	parentResourceId: videoResourceId,
+			// })
+			//
+			// await options.adapter?.createContentResource({
+			// 	id: `transcript-${videoResourceId}`,
+			// 	type: 'transcript',
+			// 	fields: {
+			// 		transcript,
+			// 	},
+			// 	createdById: videoResource.createdById,
+			// })
+			//
+			// await options.adapter?.addResourceToResource({
+			// 	childResourceId: `transcript-${videoResourceId}`,
+			// 	parentResourceId: videoResourceId,
+			// })
+			//
+			// await options.adapter?.createContentResource({
+			// 	id: `srt-${videoResourceId}`,
+			// 	type: 'srt',
+			// 	fields: {
+			// 		srt,
+			// 	},
+			// 	createdById: videoResource.createdById,
+			// })
+			//
+			// await options.adapter?.addResourceToResource({
+			// 	childResourceId: `srt-${videoResourceId}`,
+			// 	parentResourceId: videoResourceId,
+			// })
+			//
+			// await options.adapter?.createContentResource({
+			// 	id: `word-level-srt-${videoResourceId}`,
+			// 	type: 'word-level-srt',
+			// 	fields: {
+			// 		wordLevelSrt,
+			// 	},
+			// 	createdById: videoResource.createdById,
+			// })
+			//
+			// await options.adapter?.addResourceToResource({
+			// 	childResourceId: `word-level-srt-${videoResourceId}`,
+			// 	parentResourceId: videoResourceId,
+			// })
+
+			await options.adapter?.updateContentResourceFields({
+				id: videoResourceId as string,
+				fields: {
+					transcript,
+					srt,
+					wordLevelSrt,
+				},
+			})
+
+			await options.inngest.send({
+				name: VIDEO_TRANSCRIPT_READY_EVENT,
+				data: {
+					videoResourceId,
+				},
+			})
+
+			if (srt && wordLevelSrt && videoResourceId) {
+				await options.inngest.send({
+					name: VIDEO_SRT_READY_EVENT,
+					data: {
+						videoResourceId: videoResourceId,
+					},
+				})
+			}
+			return {
+				status: 200,
+				body: null,
+				headers: { 'Content-Type': 'application/json' },
+				cookies,
+			}
+	}
+
+	throw new Error('Invalid provider type')
+}

package/src/actions/prices-coupon-for-code.ts

@@ -0,0 +1,91 @@
+import { isBefore } from 'date-fns'
+
+import type { Coupon } from '@coursebuilder/core/schemas'
+import type {
+	InternalOptions,
+	RequestInternal,
+	ResponseInternal,
+} from '@coursebuilder/core/types'
+
+import type { Cookie } from '../runtime/cookie'
+
+const validateCoupon = (coupon: Coupon | null, productIds: string[] = []) => {
+	if (!coupon) {
+		return {
+			isValid: false,
+			isRedeemable: false,
+			error: 'coupon-not-found',
+		}
+	}
+
+	const isUsedUp =
+		coupon.maxUses > 0 ? coupon.usedCount >= coupon.maxUses : false
+
+	const isExpired = coupon.expires
+		? isBefore(new Date(coupon.expires), new Date())
+		: false
+
+	if (
+		coupon.restrictedToProductId &&
+		!productIds.includes(coupon.restrictedToProductId)
+	) {
+		return {
+			isValid: false,
+			isRedeemable: false,
+			error: 'coupon-not-valid-for-product',
+		}
+	}
+
+	const isValid = !isUsedUp && !isExpired
+
+	return {
+		isExpired,
+		isUsedUp,
+		isRedeemable:
+			isValid && Number(coupon.percentageDiscount) >= 1 && !coupon.default,
+		isValid,
+	}
+}
+
+export async function getCouponForCode(
+	request: RequestInternal,
+	cookies: Cookie[],
+	options: InternalOptions,
+): Promise<ResponseInternal> {
+	const { code, productIds } = request.body || {}
+
+	if (!code)
+		return {
+			body: null,
+			headers: { 'Content-Type': 'application/json' },
+			cookies,
+		}
+
+	let couponFromCode = code && (await options.adapter?.getCoupon(code))
+
+	if (couponFromCode) {
+		const is100Percent =
+			productIds.length === 0 &&
+			couponFromCode.restrictedToProductId &&
+			couponFromCode.percentageDiscount === 1
+
+		const validatedCoupon = validateCoupon(
+			couponFromCode,
+			is100Percent ? [couponFromCode?.restrictedToProductId] : productIds,
+		)
+		return {
+			body: {
+				...couponFromCode,
+				...validatedCoupon,
+			},
+			headers: { 'Content-Type': 'application/json' },
+			cookies,
+		}
+	}
+
+	return {
+		body: null,
+		headers: { 'Content-Type': 'application/json' },
+		cookies,
+	}
+}