@coursebuilder/server 0.1.0-canary.0.0c9beb2ae

package/src/actions/prices-formatted.ts

@@ -0,0 +1,313 @@
+import { isAfter } from 'date-fns'
+import { z } from 'zod'
+
+import { formatPricesForProduct } from '@coursebuilder/commerce/format-prices-for-product'
+import type { ServerAdapter } from '../adapter'
+import { Coupon, Purchase } from '@coursebuilder/core/schemas'
+import { PricingFormattedInputSchema } from '@coursebuilder/core/schemas/pricing-formatted-input-schema'
+import type {
+	InternalOptions,
+	RequestInternal,
+	ResponseInternal,
+} from '@coursebuilder/core/types'
+import { find } from '@coursebuilder/nodash'
+
+import type { Cookie } from '../runtime/cookie'
+
+const checkForAnyAvailableUpgrades = async ({
+	upgradeFromPurchaseId,
+	productId,
+	purchases,
+	courseBuilderAdapter,
+}: {
+	upgradeFromPurchaseId: string | undefined
+	productId: string
+	purchases: Array<{ id: string; productId: string; status: string }>
+	country: string
+	courseBuilderAdapter: ServerAdapter
+}) => {
+	if (upgradeFromPurchaseId) return upgradeFromPurchaseId
+
+	const validPurchases = getValidPurchases(purchases)
+	const productIdsAlreadyPurchased = validPurchases.map(
+		(purchase) => purchase.productId,
+	)
+
+	const potentialUpgrades =
+		await courseBuilderAdapter.availableUpgradesForProduct(
+			validPurchases,
+			productId,
+		)
+
+	type AvailableUpgrade = Awaited<
+		ReturnType<typeof courseBuilderAdapter.availableUpgradesForProduct>
+	>[0]
+	// filter out potential upgrades that have already been purchased
+	const availableUpgrades = potentialUpgrades.filter<AvailableUpgrade>(
+		(
+			availableUpgrade: AvailableUpgrade,
+		): availableUpgrade is AvailableUpgrade => {
+			return !productIdsAlreadyPurchased.includes(
+				availableUpgrade.upgradableTo.id,
+			)
+		},
+	)
+
+	return find(validPurchases, (purchase) => {
+		const upgradeProductIds = availableUpgrades.map(
+			(upgrade) => upgrade.upgradableFrom.id,
+		)
+		return upgradeProductIds.includes(purchase.productId)
+	})?.id
+}
+
+const getValidPurchases = (purchases: any[]): Purchase[] => {
+	return purchases.filter((purchase: Purchase) =>
+		['Valid', 'Restricted'].includes(purchase.status),
+	)
+}
+
+function couponIsValid(coupon?: Coupon | null) {
+	if (coupon) {
+		const unlimitedUse = coupon.maxUses === -1
+		const now = new Date()
+		if (!unlimitedUse && coupon.usedCount >= coupon.maxUses) return false
+		if (coupon.expires && isAfter(now, coupon.expires)) return false
+	} else {
+		return false
+	}
+	return true
+}
+
+async function getActiveMerchantCoupon({
+	productId,
+	siteCouponId,
+	code,
+	courseBuilderAdapter,
+}: {
+	productId: string | undefined
+	siteCouponId: string | null | undefined
+	code: string | undefined
+	courseBuilderAdapter: ServerAdapter
+}) {
+	let activeMerchantCoupon = null
+	let usedCouponId
+
+	const defaultCoupons = productId
+		? await courseBuilderAdapter.getDefaultCoupon([productId])
+		: undefined
+
+	const defaultMerchantCoupon = defaultCoupons
+		? defaultCoupons.defaultMerchantCoupon
+		: null
+
+	const incomingCoupon = await courseBuilderAdapter.couponForIdOrCode({
+		couponId: siteCouponId,
+		code,
+	})
+
+	if (
+		// compare the discounts if there is a coupon and site/sale running
+		incomingCoupon?.merchantCoupon &&
+		couponIsValid(incomingCoupon) &&
+		defaultMerchantCoupon
+	) {
+		// use whichever coupon provides the bigger discount
+		const { merchantCoupon: incomingMerchantCoupon } = incomingCoupon
+
+		// Get product price to compare actual discount amounts
+		const product = productId
+			? await courseBuilderAdapter.getProduct(productId)
+			: null
+		const price = product
+			? await courseBuilderAdapter.getPriceForProduct(productId!)
+			: null
+		const unitPrice = price?.unitAmount || 0
+
+		// Calculate actual discount amounts in dollars
+		const incomingDiscountAmount =
+			incomingMerchantCoupon.amountDiscount !== null &&
+			incomingMerchantCoupon.amountDiscount !== undefined &&
+			incomingMerchantCoupon.amountDiscount > 0
+				? incomingMerchantCoupon.amountDiscount / 100 // Convert cents to dollars
+				: (incomingMerchantCoupon.percentageDiscount ?? 0) * unitPrice
+
+		const defaultDiscountAmount =
+			defaultMerchantCoupon.amountDiscount !== null &&
+			defaultMerchantCoupon.amountDiscount !== undefined &&
+			defaultMerchantCoupon.amountDiscount > 0
+				? defaultMerchantCoupon.amountDiscount / 100 // Convert cents to dollars
+				: (defaultMerchantCoupon.percentageDiscount ?? 0) * unitPrice
+
+		if (incomingDiscountAmount >= defaultDiscountAmount) {
+			activeMerchantCoupon = incomingMerchantCoupon
+			usedCouponId = incomingCoupon.id
+		} else {
+			activeMerchantCoupon = defaultMerchantCoupon
+			usedCouponId = defaultCoupons?.defaultCoupon?.id
+		}
+	} else if (
+		// if it's a coupon, use it
+		incomingCoupon?.merchantCoupon &&
+		couponIsValid(incomingCoupon)
+	) {
+		activeMerchantCoupon = incomingCoupon.merchantCoupon
+		usedCouponId = incomingCoupon.id
+	} else if (
+		// if a sale is running, use that
+		defaultMerchantCoupon
+	) {
+		activeMerchantCoupon = defaultMerchantCoupon
+		usedCouponId = defaultCoupons?.defaultCoupon?.id
+	}
+
+	const defaultCoupon = defaultCoupons?.defaultCoupon
+
+	return {
+		usedCouponId,
+		activeMerchantCoupon,
+		...(defaultCoupon &&
+			defaultCoupon.merchantCouponId === activeMerchantCoupon?.id && {
+				defaultCoupon,
+			}),
+	}
+}
+
+const CheckForAvailableCouponsSchema = PricingFormattedInputSchema.pick({
+	merchantCoupon: true,
+	couponId: true,
+	code: true,
+	productId: true,
+})
+type CheckForAvailableCoupons = z.infer<typeof CheckForAvailableCouponsSchema>
+
+const checkForAvailableCoupons = async ({
+	merchantCoupon,
+	couponId,
+	productId,
+	courseBuilderAdapter,
+}: CheckForAvailableCoupons & {
+	courseBuilderAdapter: ServerAdapter
+}) => {
+	// explicit incoming merchant coupons are honored
+	// without checking for other potential coupons
+	// if there is no explicit incoming merchant coupon
+	// we check for default/global coupon or an incoming code
+	if (merchantCoupon?.id) {
+		return {
+			activeMerchantCoupon: merchantCoupon,
+			defaultCoupon: undefined,
+		}
+	} else {
+		const { activeMerchantCoupon, defaultCoupon, usedCouponId } =
+			await getActiveMerchantCoupon({
+				siteCouponId: couponId,
+				productId,
+				code: undefined,
+				courseBuilderAdapter,
+			})
+
+		const minimalDefaultCoupon = defaultCoupon && {
+			expires: defaultCoupon.expires?.toISOString(),
+			percentageDiscount: defaultCoupon.percentageDiscount?.toString() || '0',
+		}
+
+		return {
+			activeMerchantCoupon,
+			defaultCoupon,
+			usedCouponId,
+		}
+	}
+}
+
+export async function getPricesFormatted(
+	request: RequestInternal,
+	cookies: Cookie[],
+	options: InternalOptions,
+): Promise<ResponseInternal> {
+	const currentUser = options.getCurrentUser
+		? await options.getCurrentUser()
+		: null
+	const {
+		productId,
+		quantity = 1,
+		couponId,
+		merchantCoupon,
+		upgradeFromPurchaseId: _upgradeFromPurchaseId,
+		autoApplyPPP,
+		userId = currentUser?.id,
+	} = PricingFormattedInputSchema.parse(request.body)
+
+	if (!productId) return { status: 400, body: 'productId is required' }
+
+	if (!options.adapter) return { status: 400, body: 'Adapter not found' }
+
+	const purchases = getValidPurchases(
+		await options.adapter.getPurchasesForUser(userId),
+	)
+
+	const country =
+		request.headers?.['x-vercel-ip-country'] ||
+		request.body?.country ||
+		process.env.DEFAULT_COUNTRY ||
+		'US'
+
+	let upgradeFromPurchaseId = await checkForAnyAvailableUpgrades({
+		upgradeFromPurchaseId: _upgradeFromPurchaseId,
+		productId,
+		purchases,
+		country,
+		courseBuilderAdapter: options.adapter,
+	})
+
+	const restrictedPurchase = purchases.find((purchase) => {
+		return purchase.productId === productId && purchase.status === 'Restricted'
+	})
+
+	if (restrictedPurchase) {
+		const validPurchase = purchases.find((purchase) => {
+			return purchase.productId === productId && purchase.status === 'Valid'
+		})
+
+		if (!validPurchase) {
+			upgradeFromPurchaseId = restrictedPurchase.id
+		}
+	}
+
+	const { activeMerchantCoupon, defaultCoupon, usedCouponId } =
+		await checkForAvailableCoupons({
+			merchantCoupon,
+			couponId,
+			productId,
+			courseBuilderAdapter: options.adapter,
+		})
+	const usedCoupon = usedCouponId
+		? await options.adapter.getCoupon(usedCouponId)
+		: null
+	const productPrices = await formatPricesForProduct({
+		productId,
+		country,
+		quantity,
+		merchantCouponId: activeMerchantCoupon?.id,
+		...(upgradeFromPurchaseId && { upgradeFromPurchaseId }),
+		userId,
+		autoApplyPPP,
+		usedCouponId,
+		ctx: options.adapter,
+	})
+
+	return {
+		body: {
+			...productPrices,
+			...(defaultCoupon && { defaultCoupon }),
+			...(usedCoupon && {
+				usedCoupon,
+				usedCouponId,
+			}),
+		},
+		headers: {
+			'Content-Type': 'application/json',
+		},
+		cookies,
+	}
+}

package/src/actions/process-refund.ts

@@ -0,0 +1,2 @@
+/** HTTP-compatible refund operation owned by the commerce engine. */
+export { processRefund } from '@coursebuilder/commerce/process-refund'

package/src/actions/redeem.ts

@@ -0,0 +1,2 @@
+/** HTTP-compatible redemption operation owned by the commerce engine. */
+export { redeem } from '@coursebuilder/commerce/redeem'

package/src/actions/transfer-purchase.ts

@@ -0,0 +1,2 @@
+/** HTTP-compatible purchase transfer operation owned by the commerce engine. */
+export { transferPurchase } from '@coursebuilder/commerce/transfer-purchase'

package/src/actions/user-lookup.ts

@@ -0,0 +1,37 @@
+import type {
+	InternalOptions,
+	RequestInternal,
+	ResponseInternal,
+} from '@coursebuilder/core/types'
+
+import type { Cookie } from '../runtime/cookie'
+import { logger } from '../runtime/logger'
+
+export async function userLookup(
+	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.query?.email as string) || (request.body?.email as string)
+
+	try {
+		const user = await options.adapter.getUserWithPurchasersByEmail(email)
+		return {
+			status: 200,
+			body: JSON.stringify(user),
+		}
+	} catch (e) {
+		logger.error(e instanceof Error ? e : new Error(String(e)), {
+			context: 'user-lookup.by-email',
+			hasEmail: Boolean(email),
+			emailSource: request.query?.email ? 'query' : 'body',
+		})
+		throw new Error('unable-to-lookup-user')
+	}
+}

package/src/adapter.ts

@@ -0,0 +1,28 @@
+import type { AuthStoragePort } from '@coursebuilder/core/auth'
+import type {
+	CatalogPort,
+	ContentResourcePort,
+	CouponPort,
+	EntitlementPort,
+	IdentityPort,
+	MerchantPort,
+	OrganizationPort,
+	ProgressPort,
+	PurchasePort,
+	SubscriptionPort,
+} from '@coursebuilder/core/ports'
+
+/** Capability composition required by the Course Builder server facade. */
+export type ServerAdapter = AuthStoragePort &
+	CatalogPort &
+	ContentResourcePort &
+	CouponPort &
+	EntitlementPort &
+	IdentityPort &
+	MerchantPort &
+	OrganizationPort &
+	ProgressPort &
+	PurchasePort &
+	SubscriptionPort & {
+		client: unknown
+	}

package/src/create-inngest-middleware.ts

@@ -0,0 +1,157 @@
+import {
+	EventSchemas,
+	GetEvents,
+	GetFunctionInput,
+	Handler,
+	Inngest,
+	InngestFunction,
+	InngestMiddleware,
+} from 'inngest'
+
+import type { ServerAdapter } from './adapter'
+import { mockServerAdapter } from './mock-adapter'
+import { mockPaymentProvider } from './mock-payment-provider'
+import type {
+	CourseBuilderAuthConfig,
+	CourseBuilderEmailProvider,
+} from '@coursebuilder/core/auth'
+import type { CourseBuilderCoreEvents } from '@coursebuilder/core/events'
+import type { TranscriptionConfig } from '@coursebuilder/core/providers'
+import {
+	LlmProviderConfig,
+	MockOpenAIProvider,
+} from '@coursebuilder/core/providers/openai'
+import {
+	MockPartykitProvider,
+	PartyProviderConfig,
+} from '@coursebuilder/core/providers/partykit'
+import {
+	mockSlackProvider,
+	NotificationProviderConfig,
+} from '@coursebuilder/core/providers/slack'
+import { PaymentsProviderConfig } from '@coursebuilder/core/types'
+
+const MockTranscriptionProvider: TranscriptionConfig = {
+	id: 'mock-transcription',
+	name: 'Mock Transcription',
+	type: 'transcription',
+	options: {
+		apiKey: 'mock-api-key',
+		callbackUrl: 'mock-callback-url',
+	},
+	apiKey: 'mock-api-key',
+	callbackUrl: 'mock-callback-url',
+	getCallbackUrl: () => 'mock-callback-url',
+	initiateTranscription: async () => ({ mock: 'transcription' }),
+	handleCallback: () => ({
+		srt: 'mock-srt',
+		transcript: 'mock-transcript',
+		wordLevelSrt: 'mock-word-level-srt',
+	}),
+}
+
+export interface CoreInngestContext {
+	db: ServerAdapter
+	siteRootUrl: string
+	transcriptProvider: TranscriptionConfig
+	openaiProvider: LlmProviderConfig
+	partyProvider: PartyProviderConfig
+	paymentProvider?: PaymentsProviderConfig
+	emailProvider?: CourseBuilderEmailProvider
+	notificationProvider?: NotificationProviderConfig
+	getAuthConfig: () => CourseBuilderAuthConfig
+	mediaUploadProvider: {
+		deleteFiles: (fileKey: string) => Promise<{ success: boolean }>
+	}
+}
+
+export type CoreInngestFunctionInput = GetFunctionInput<CoreInngest>
+
+/** A server composition input with a statically limited context and event. */
+export type CourseBuilderHandlerInput<
+	TContext extends Partial<CoreInngestContext>,
+	TEventName extends Extract<keyof CourseBuilderCoreEvents, string>,
+	TEvent extends CourseBuilderCoreEvents[TEventName] =
+		CourseBuilderCoreEvents[TEventName],
+> = Omit<CoreInngestFunctionInput, keyof CoreInngestContext | 'event'> &
+	TContext & {
+		event: TEvent
+	}
+
+export type CoreInngestFunctionInputFor<
+	TContext extends Partial<CoreInngestContext>,
+	TEventName extends Extract<keyof CourseBuilderCoreEvents, string>,
+	TEvent extends CourseBuilderCoreEvents[TEventName] =
+		CourseBuilderCoreEvents[TEventName],
+> = CourseBuilderHandlerInput<TContext, TEventName, TEvent>
+
+export type CoreInngestTrigger = InngestFunction.Trigger<
+	keyof GetEvents<CoreInngest>
+>
+export type CoreInngestHandler = Handler.Any
+
+export type CourseBuilderFunctionDefinition = {
+	config: { id: string }
+	trigger: CoreInngestTrigger
+	handler: CoreInngestHandler
+}
+
+/** Validates function definitions without widening their inferred config types. */
+export const defineCourseBuilderFunctions = <TFunctions extends unknown[]>(
+	functions: TFunctions &
+		(TFunctions[number] extends CourseBuilderFunctionDefinition
+			? unknown
+			: never),
+): TFunctions => functions
+
+export const createInngestMiddleware = <
+	TCourseBuilderContext extends CoreInngestContext = CoreInngestContext,
+>(
+	context: TCourseBuilderContext,
+) => {
+	return new InngestMiddleware({
+		name: 'Course Builder Middleware',
+		init() {
+			return {
+				onFunctionRun() {
+					return {
+						transformInput() {
+							// kill me - this middleware is just for types
+							type MappedCoreContext = {
+								[K in keyof TCourseBuilderContext]: TCourseBuilderContext[K]
+							}
+
+							return { ctx: context as unknown as MappedCoreContext }
+						},
+					}
+				},
+			}
+		},
+	})
+}
+
+const schemas = new EventSchemas().fromRecord<CourseBuilderCoreEvents>()
+
+export const coreInngest = new Inngest({
+	id: 'core-inngest',
+	schemas,
+	middleware: [
+		createInngestMiddleware({
+			db: mockServerAdapter,
+			siteRootUrl: '',
+			partyKitRootUrl: '',
+			transcriptProvider: MockTranscriptionProvider,
+			openaiProvider: MockOpenAIProvider,
+			partyProvider: MockPartykitProvider,
+			paymentProvider: mockPaymentProvider,
+			emailProvider: {} as CourseBuilderEmailProvider,
+			notificationProvider: mockSlackProvider,
+			getAuthConfig: () => ({}) as CourseBuilderAuthConfig,
+			mediaUploadProvider: {
+				deleteFiles: async (_) => Promise.resolve({ success: true }),
+			},
+		}),
+	],
+})
+
+export type CoreInngest = typeof coreInngest

package/src/http-actions.ts

@@ -0,0 +1,29 @@
+import type {
+	InternalOptions,
+	RequestInternal,
+	ResponseInternal,
+} from '@coursebuilder/core/types'
+
+import type { Cookie } from './runtime/cookie'
+
+/** Serve the persisted SRT body for Mux's HTTP callback. */
+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,
+	}
+}

package/src/http-router.ts

@@ -0,0 +1,79 @@
+import type {
+	RequestInternal,
+	ResponseInternal,
+} from '@coursebuilder/core/types'
+
+import { checkout } from './actions/checkout'
+import { claimed } from './actions/claimed'
+import { createMagicLink } from './actions/create-magic-link'
+import * as actions from './actions/index'
+import { getPricesFormatted } from './actions/prices-formatted'
+import { processRefund } from './actions/process-refund'
+import { redeem } from './actions/redeem'
+import { transferPurchase } from './actions/transfer-purchase'
+import { userLookup } from './actions/user-lookup'
+import type { CourseBuilderConfig } from './http'
+import { srt } from './http-actions'
+import { init } from './runtime/init'
+import { UnknownAction } from './runtime/web'
+
+/**
+ * Route an internal Course Builder request to its runtime action.
+ *
+ * @param request - Parsed internal request.
+ * @param courseBuilderOptions - Server runtime configuration.
+ * @returns The internal response emitted by the selected action.
+ */
+export async function CourseBuilderInternal(
+	request: RequestInternal,
+	courseBuilderOptions: CourseBuilderConfig,
+): Promise<ResponseInternal> {
+	const { action, providerId, method } = request
+
+	const { options, cookies } = await init({
+		courseBuilderOptions,
+		action,
+		providerId,
+		url: request.url,
+		cookies: request.cookies,
+		isPost: method === 'POST',
+	})
+
+	if (method === 'GET') {
+		switch (action) {
+			case 'srt':
+				return await srt(request, cookies, options)
+			case 'session':
+				return await actions.session(options, cookies)
+			case 'subscriber':
+				return await actions.getSubscriber(options, cookies)
+			case 'purchases':
+				return await actions.getUserPurchases(request, cookies, options)
+		}
+	} else {
+		switch (action) {
+			case 'prices-formatted':
+				return await getPricesFormatted(request, cookies, options)
+			case 'redeem':
+				return await redeem(request, cookies, options)
+			case 'refund':
+				return await processRefund(request, cookies, options)
+			case 'checkout':
+				return await checkout(request, cookies, options)
+			case 'claimed':
+				return await claimed(request, cookies, options)
+			case 'webhook':
+				return await actions.webhook(request, cookies, options)
+			case 'subscribe-to-list':
+				return await actions.subscribeToList(request, cookies, options)
+			case 'lookup':
+				return await userLookup(request, cookies, options)
+			case 'create-magic-link':
+				return await createMagicLink(request, cookies, options)
+			case 'transfer':
+				return await transferPurchase(request, cookies, options)
+		}
+	}
+
+	throw new UnknownAction(`Cannot handle action: ${action}`)
+}

package/src/http.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it, vi } from 'vitest'
+import type { ServerAdapter } from './adapter'
+
+import { CourseBuilder, type CourseBuilderConfig } from './http'
+import { init } from './runtime/init'
+
+const createConfig = (): CourseBuilderConfig => ({
+	adapter: {
+		getContentResource: vi.fn().mockResolvedValue({
+			fields: { srt: '1\n00:00:00,000 --> 00:00:01,000\nHello' },
+		}),
+	} as unknown as ServerAdapter,
+	providers: [],
+	baseUrl: 'http://test.com',
+	basePath: '/coursebuilder',
+	authConfig: {},
+})
+
+describe('@coursebuilder/server HTTP runtime', () => {
+	it('preserves the legacy HTTP SRT callback response', async () => {
+		const url =
+			'http://test.com/coursebuilder/srt/internal?videoResourceId=video-1'
+		const serverResponse = await CourseBuilder(new Request(url), createConfig())
+
+		expect(serverResponse.status).toBe(200)
+		expect(serverResponse.headers.get('content-type')).toBe('application/text')
+		expect(await serverResponse.text()).toContain('Hello')
+	})
+
+	it('preserves request cookie conversion', async () => {
+		const { cookies } = await init({
+			url: new URL('http://test.com/coursebuilder/session'),
+			courseBuilderOptions: createConfig(),
+			action: 'session',
+			isPost: false,
+			cookies: {
+				sl_ref: 'workshop-promo',
+				ignored: undefined,
+			},
+		})
+
+		expect(cookies).toEqual([
+			{ name: 'sl_ref', value: 'workshop-promo', options: {} },
+		])
+	})
+})