@coursebuilder/server 0.1.0-canary.0.0c9beb2ae

package/src/runtime/merge.ts

@@ -0,0 +1,25 @@
+// Source: https://stackoverflow.com/a/34749873/5364135
+
+/** Simple object check */
+function isObject(item: any): boolean {
+	return item && typeof item === 'object' && !Array.isArray(item)
+}
+
+/** Deep merge two objects */
+export function merge(target: any, ...sources: any[]): any {
+	if (!sources.length) return target
+	const source = sources.shift()
+
+	if (isObject(target) && isObject(source)) {
+		for (const key in source) {
+			if (isObject(source[key])) {
+				if (!target[key]) Object.assign(target, { [key]: {} })
+				merge(target[key], source[key])
+			} else {
+				Object.assign(target, { [key]: source[key] })
+			}
+		}
+	}
+
+	return merge(target, ...sources)
+}

package/src/runtime/providers.ts

@@ -0,0 +1,38 @@
+import { Provider } from '@coursebuilder/core/providers'
+import { InternalProvider } from '@coursebuilder/core/types'
+
+import { CourseBuilderConfig } from '../http'
+import { merge } from './merge'
+
+export default function parseProviders(params: {
+	providers: Provider[]
+	url: URL
+	providerId?: string
+	options: CourseBuilderConfig
+}): {
+	providers: InternalProvider[]
+	provider?: InternalProvider
+} {
+	const { providerId, options } = params
+
+	const providers = params.providers.map((p) => {
+		const provider = typeof p === 'function' ? p() : p
+		const { options: userOptions, ...defaults } = provider
+
+		if (!userOptions) {
+			throw new Error(`Provider ${provider.id} is missing options`)
+		}
+
+		const { paymentsAdapter, ...userOptionsWithPaymentsAdapter } = userOptions
+
+		return {
+			...merge(defaults, userOptionsWithPaymentsAdapter),
+			...(paymentsAdapter ? { options: paymentsAdapter } : {}),
+		}
+	})
+
+	return {
+		providers,
+		provider: providers.find(({ id }) => id === providerId),
+	}
+}

package/src/runtime/web.ts

@@ -0,0 +1,199 @@
+import { parse as parseCookie, serialize } from 'cookie'
+
+import { CourseBuilderError } from '@coursebuilder/core/errors'
+import {
+	CourseBuilderAction,
+	RequestInternal,
+	ResponseInternal,
+} from '@coursebuilder/core/types'
+
+import { CourseBuilderConfig } from '../http'
+import { isCourseBuilderAction } from './actions'
+import { logger } from './logger'
+
+async function getBody(
+	req: Request,
+	config: CourseBuilderConfig,
+): Promise<Record<string, any> | undefined> {
+	const headers = Object.fromEntries(req.headers)
+	const isStripeWebhook = ['stripe-signature'].every((prop: string) => {
+		return prop in headers
+	})
+
+	if (isStripeWebhook) {
+		let parsedBody
+		const stripeProvider = config.providers.find((p: any) => p.id === 'stripe')
+		parsedBody = await req.text()
+		stripeProvider?.options?.paymentsAdapter.verifyWebhookSignature(
+			parsedBody,
+			headers['stripe-signature'],
+		)
+		parsedBody = JSON.parse(parsedBody)
+		return parsedBody
+	}
+
+	if (!('body' in req) || !req.body || req.method !== 'POST') return
+
+	const contentType = req.headers.get('content-type')
+	if (contentType?.includes('application/json')) {
+		const rawBody = await req.text()
+		if (rawBody.trim().length === 0) return undefined
+
+		try {
+			return JSON.parse(rawBody)
+		} catch (e) {
+			logger.error(e instanceof Error ? e : new Error(String(e)), {
+				context: 'web.body-parse',
+				method: req.method,
+				contentType,
+			})
+			return undefined
+		}
+	} else if (contentType?.includes('application/x-www-form-urlencoded')) {
+		const params = new URLSearchParams(await req.text())
+		return Object.fromEntries(params)
+	}
+}
+
+/**
+ * takes a `Request` object and converts it into an internal request object
+ * that we use throughout the system
+ * @param req
+ * @param config
+ * @returns
+ */
+export async function toInternalRequest(
+	req: Request,
+	config: CourseBuilderConfig,
+): Promise<RequestInternal | undefined> {
+	try {
+		config.basePath ??= '/coursebuilder'
+
+		const url = new URL(req.url)
+
+		const { action, providerId } = parseActionAndProviderId(
+			url.pathname,
+			config.basePath,
+		)
+
+		logger.debug('web.action-parsed', {
+			pathname: url.pathname,
+			action,
+			providerId: providerId ?? null,
+			searchParamCount: url.searchParams.size,
+		})
+
+		const parsedCookies = parseCookie(req.headers.get('cookie') ?? '') ?? {}
+
+		logger.debug('web.request-parsed', {
+			action,
+			method: req.method,
+			providerId: providerId ?? null,
+			hasCookieHeader: Boolean(req.headers.get('cookie')),
+			parsedCookieCount: Object.keys(parsedCookies).length,
+			hasSl_ref: 'sl_ref' in parsedCookies,
+		})
+
+		return {
+			url,
+			action,
+			providerId,
+			method: req.method as 'POST' | 'GET',
+			headers: Object.fromEntries(req.headers),
+			body: req.body ? await getBody(req, config) : undefined,
+			cookies: parsedCookies,
+			error: url.searchParams.get('error') ?? undefined,
+			query: Object.fromEntries(url.searchParams),
+		}
+	} catch (e) {
+		logger.error(e instanceof Error ? e : new Error(String(e)), {
+			context: 'web.to-internal-request',
+			method: req.method,
+			url: req.url,
+			basePath: config.basePath,
+		})
+		logger.debug('web.request-context', {
+			method: req.method,
+			url: req.url,
+			hasBody: Boolean(req.body),
+			hasCookieHeader: Boolean(req.headers.get('cookie')),
+		})
+	}
+}
+
+export function parseActionAndProviderId(
+	pathname: string,
+	base: string,
+): {
+	action: CourseBuilderAction
+	providerId?: string
+} {
+	const a = pathname.match(new RegExp(`^${base}(.+)`))
+
+	if (a === null) throw new UnknownAction(`Cannot parse action at ${pathname}`)
+
+	const [_, actionAndProviderId] = a
+
+	const b = actionAndProviderId.replace(/^\//, '').split('/')
+
+	if (b.length !== 1 && b.length !== 2)
+		throw new UnknownAction(`**Cannot parse action at ${pathname}`)
+
+	const [action, providerId] = b
+
+	if (!isCourseBuilderAction(action))
+		throw new UnknownAction(`***Cannot parse action at ${pathname}`)
+
+	if (
+		providerId &&
+		![
+			'webhook',
+			'srt',
+			'session',
+			'subscribe-to-list',
+			'checkout',
+			'redeem',
+			'subscriber',
+			'lookup',
+			'claimed',
+			'nameUpdate',
+			'transfer',
+			'refund',
+			'create-magic-link',
+		].includes(action)
+	)
+		throw new UnknownAction(
+			`**** Cannot parse action at ${pathname}. add it to the list in web.ts?`,
+		)
+
+	return { action, providerId }
+}
+
+export class UnknownAction extends CourseBuilderError {
+	static type = 'UnknownAction'
+}
+
+export function toResponse(res: ResponseInternal): Response {
+	const headers = new Headers(res.headers)
+
+	res.cookies?.forEach((cookie) => {
+		const { name, value, options } = cookie
+		const cookieHeader = serialize(name, value, options)
+		if (headers.has('Set-Cookie')) headers.append('Set-Cookie', cookieHeader)
+		else headers.set('Set-Cookie', cookieHeader)
+	})
+
+	let body = res.body
+
+	if (headers.get('content-type') === 'application/json')
+		body = JSON.stringify(res.body)
+	else if (headers.get('content-type') === 'application/x-www-form-urlencoded')
+		body = new URLSearchParams(res.body).toString()
+
+	const status = res.redirect ? 302 : (res.status ?? 200)
+	const response = new Response(body, { headers, status })
+
+	if (res.redirect) response.headers.set('Location', res.redirect)
+
+	return response
+}

package/src/streaming-chat-prompt-executor.ts

@@ -0,0 +1,43 @@
+import { type ModelMessage } from 'ai'
+
+import { LlmProviderConfig } from '@coursebuilder/core/providers/openai'
+import { AIMessage, type AIOutput } from '@coursebuilder/core/types'
+
+export type ChatCompletionRequestMessage = ModelMessage
+
+type PromptStepOptions = {
+	requestId: string
+	promptMessages: ModelMessage[]
+	model: string
+	provider: LlmProviderConfig
+}
+
+export async function streamingChatPromptExecutor({
+	requestId,
+	promptMessages,
+	model,
+	provider,
+}: PromptStepOptions) {
+	const result: AIOutput | null = await provider.createChatCompletion({
+		messages: promptMessages,
+		chatId: requestId,
+		model,
+	})
+
+	if (!result) {
+		throw new Error('Chat completion returned null')
+	}
+
+	if ('error' in result) {
+		throw new Error(result.error)
+	}
+
+	const message = result as AIMessage
+	return [
+		...promptMessages,
+		{
+			role: 'assistant',
+			content: message.content,
+		} as ModelMessage,
+	]
+}

package/src/type-contracts.test.ts

@@ -0,0 +1,167 @@
+import { describe, expectTypeOf, it } from 'vitest'
+
+import {
+	NEW_PURCHASE_CREATED_EVENT,
+	PURCHASE_STATUS_UPDATED_EVENT,
+	STRIPE_CHECKOUT_SESSION_COMPLETED_EVENT,
+	STRIPE_CUSTOMER_SUBSCRIPTION_CREATED_EVENT,
+	STRIPE_CUSTOMER_SUBSCRIPTION_UPDATED_EVENT,
+	STRIPE_INVOICE_PAYMENT_SUCCEEDED_EVENT,
+	VIDEO_STATUS_CHECK_EVENT,
+	type CourseBuilderCoreEvents,
+} from '@coursebuilder/core/events'
+
+import {
+	defineCourseBuilderFunctions,
+	type CoreInngestContext,
+	type CourseBuilderHandlerInput,
+} from './create-inngest-middleware'
+
+type VideoStatusInput = CourseBuilderHandlerInput<
+	Pick<CoreInngestContext, 'db' | 'mediaUploadProvider'>,
+	typeof VIDEO_STATUS_CHECK_EVENT
+>
+
+type VideoStatusEvent = CourseBuilderCoreEvents[typeof VIDEO_STATUS_CHECK_EVENT]
+
+type CommercePurchaseInput = CourseBuilderHandlerInput<
+	Pick<
+		CoreInngestContext,
+		'db' | 'siteRootUrl' | 'emailProvider' | 'getAuthConfig'
+	>,
+	typeof NEW_PURCHASE_CREATED_EVENT
+>
+
+type CommerceSlackInput = CourseBuilderHandlerInput<
+	Pick<CoreInngestContext, 'db' | 'notificationProvider'> &
+		Required<Pick<CoreInngestContext, 'paymentProvider'>>,
+	typeof NEW_PURCHASE_CREATED_EVENT
+>
+
+type PurchaseStatusInput = CourseBuilderHandlerInput<
+	Pick<CoreInngestContext, 'db'>,
+	typeof PURCHASE_STATUS_UPDATED_EVENT
+>
+
+type StripeCheckoutInput = CourseBuilderHandlerInput<
+	Pick<CoreInngestContext, 'db' | 'notificationProvider'> &
+		Required<Pick<CoreInngestContext, 'paymentProvider'>>,
+	typeof STRIPE_CHECKOUT_SESSION_COMPLETED_EVENT
+>
+
+type StripeInvoiceInput = CourseBuilderHandlerInput<
+	Pick<CoreInngestContext, 'db' | 'notificationProvider'>,
+	typeof STRIPE_INVOICE_PAYMENT_SUCCEEDED_EVENT
+>
+
+type StripeSubscriptionCreatedInput = CourseBuilderHandlerInput<
+	Pick<CoreInngestContext, never>,
+	typeof STRIPE_CUSTOMER_SUBSCRIPTION_CREATED_EVENT
+>
+
+type StripeSubscriptionUpdatedInput = CourseBuilderHandlerInput<
+	Pick<CoreInngestContext, never>,
+	typeof STRIPE_CUSTOMER_SUBSCRIPTION_UPDATED_EVENT
+>
+
+describe('@coursebuilder/server type contracts', () => {
+	it('composes provider-neutral event payloads into handler input', () => {
+		expectTypeOf<VideoStatusInput['event']>().toEqualTypeOf<VideoStatusEvent>()
+		expectTypeOf<
+			VideoStatusInput['event']['data']['videoResourceId']
+		>().toEqualTypeOf<string>()
+	})
+
+	it('limits video handler middleware context to declared capabilities', () => {
+		expectTypeOf<VideoStatusInput['db']>().toEqualTypeOf<
+			CoreInngestContext['db']
+		>()
+		expectTypeOf<VideoStatusInput['mediaUploadProvider']>().toEqualTypeOf<
+			CoreInngestContext['mediaUploadProvider']
+		>()
+		type HasCommerceProvider = 'paymentProvider' extends keyof VideoStatusInput
+			? true
+			: false
+		expectTypeOf<HasCommerceProvider>().toEqualTypeOf<false>()
+	})
+
+	it('composes commerce and Stripe event payloads into handler inputs', () => {
+		expectTypeOf<
+			CommercePurchaseInput['event']['data']['purchaseId']
+		>().toEqualTypeOf<string>()
+		expectTypeOf<
+			StripeCheckoutInput['event']['data']['stripeEvent']['type']
+		>().toEqualTypeOf<'checkout.session.completed'>()
+		expectTypeOf<
+			StripeInvoiceInput['event']['data']['stripeEvent']['type']
+		>().toEqualTypeOf<'invoice.payment_succeeded'>()
+		expectTypeOf<
+			StripeSubscriptionCreatedInput['event']['data']['stripeEvent']['type']
+		>().toEqualTypeOf<'customer.subscription.created'>()
+		expectTypeOf<
+			StripeSubscriptionUpdatedInput['event']['data']['stripeEvent']['type']
+		>().toEqualTypeOf<'customer.subscription.updated'>()
+	})
+
+	it('limits commerce and Stripe middleware contexts to their capabilities', () => {
+		expectTypeOf<CommercePurchaseInput['getAuthConfig']>().toEqualTypeOf<
+			CoreInngestContext['getAuthConfig']
+		>()
+		expectTypeOf<CommerceSlackInput['paymentProvider']>().toEqualTypeOf<
+			NonNullable<CoreInngestContext['paymentProvider']>
+		>()
+		expectTypeOf<CommerceSlackInput['notificationProvider']>().toEqualTypeOf<
+			CoreInngestContext['notificationProvider']
+		>()
+		expectTypeOf<PurchaseStatusInput['db']>().toEqualTypeOf<
+			CoreInngestContext['db']
+		>()
+		expectTypeOf<StripeCheckoutInput['paymentProvider']>().toEqualTypeOf<
+			NonNullable<CoreInngestContext['paymentProvider']>
+		>()
+
+		type CommerceHasVideoProvider =
+			'mediaUploadProvider' extends keyof CommercePurchaseInput ? true : false
+		type PurchaseStatusHasPaymentProvider =
+			'paymentProvider' extends keyof PurchaseStatusInput ? true : false
+		type StripeHasTranscriptionProvider =
+			'transcriptProvider' extends keyof StripeCheckoutInput ? true : false
+		type StripeHasAuthConfig = 'getAuthConfig' extends keyof StripeCheckoutInput
+			? true
+			: false
+		type InvoiceHasPaymentProvider =
+			'paymentProvider' extends keyof StripeInvoiceInput ? true : false
+		type SubscriptionCreatedHasDatabase =
+			'db' extends keyof StripeSubscriptionCreatedInput ? true : false
+		type SubscriptionUpdatedHasDatabase =
+			'db' extends keyof StripeSubscriptionUpdatedInput ? true : false
+
+		expectTypeOf<CommerceHasVideoProvider>().toEqualTypeOf<false>()
+		expectTypeOf<PurchaseStatusHasPaymentProvider>().toEqualTypeOf<false>()
+		expectTypeOf<StripeHasTranscriptionProvider>().toEqualTypeOf<false>()
+		expectTypeOf<StripeHasAuthConfig>().toEqualTypeOf<false>()
+		expectTypeOf<InvoiceHasPaymentProvider>().toEqualTypeOf<false>()
+		expectTypeOf<SubscriptionCreatedHasDatabase>().toEqualTypeOf<false>()
+		expectTypeOf<SubscriptionUpdatedHasDatabase>().toEqualTypeOf<false>()
+	})
+
+	it('preserves typed function registration order', () => {
+		const functions = defineCourseBuilderFunctions([
+			{
+				config: { id: 'compile-contract' },
+				trigger: { event: VIDEO_STATUS_CHECK_EVENT } as const,
+				handler: async () => undefined,
+			},
+		])
+
+		expectTypeOf(functions[0].config.id).toEqualTypeOf<string>()
+
+		// @ts-expect-error registrations must include a handler
+		defineCourseBuilderFunctions([
+			{
+				config: { id: 'invalid' },
+				trigger: { event: VIDEO_STATUS_CHECK_EVENT },
+			},
+		])
+	})
+})

package/src/web-body-parse.test.ts

@@ -0,0 +1,55 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import type { CourseBuilderConfig } from './http'
+import { logger } from './runtime/logger'
+import { toInternalRequest } from './runtime/web'
+
+const createConfig = (): CourseBuilderConfig => ({
+	providers: [],
+	baseUrl: 'http://test.com',
+	basePath: '/api/coursebuilder',
+	authConfig: {},
+})
+
+afterEach(() => {
+	vi.restoreAllMocks()
+})
+
+describe('toInternalRequest JSON body parsing', () => {
+	it('treats empty JSON request bodies as undefined without logging parse errors', async () => {
+		const errorSpy = vi.spyOn(logger, 'error').mockImplementation(() => {})
+		const request = new Request('http://test.com/api/coursebuilder/session', {
+			method: 'POST',
+			headers: {
+				'content-type': 'application/json',
+			},
+			body: '',
+		})
+
+		const internalRequest = await toInternalRequest(request, createConfig())
+
+		expect(internalRequest?.body).toBeUndefined()
+		expect(errorSpy).not.toHaveBeenCalled()
+	})
+
+	it('continues logging malformed non-empty JSON request bodies', async () => {
+		const errorSpy = vi.spyOn(logger, 'error').mockImplementation(() => {})
+		const request = new Request('http://test.com/api/coursebuilder/session', {
+			method: 'POST',
+			headers: {
+				'content-type': 'application/json',
+			},
+			body: '{',
+		})
+
+		const internalRequest = await toInternalRequest(request, createConfig())
+
+		expect(internalRequest?.body).toBeUndefined()
+		expect(errorSpy).toHaveBeenCalledTimes(1)
+		expect(errorSpy).toHaveBeenCalledWith(expect.any(SyntaxError), {
+			context: 'web.body-parse',
+			method: 'POST',
+			contentType: 'application/json',
+		})
+	})
+})