@coursebuilder/server 0.1.0-canary.0.0c9beb2ae

package/src/http.ts

@@ -0,0 +1,83 @@
+import type { Inngest } from 'inngest'
+
+import type { ServerAdapter } from './adapter'
+import type { CourseBuilderAuthConfig } from '@coursebuilder/core/auth'
+import type { Provider } from '@coursebuilder/core/providers'
+import type { User } from '@coursebuilder/core/schemas'
+import type {
+	CallbacksOptions,
+	CookiesOptions,
+} from '@coursebuilder/core/types'
+
+import { CourseBuilderInternal } from './http-router'
+import { assertConfig } from './runtime/assert'
+import { createActionURL, setEnvDefaults } from './runtime/env.js'
+import { logger, setLogger, type LoggerInstance } from './runtime/logger'
+import { toInternalRequest, toResponse } from './runtime/web'
+
+export { createActionURL, setEnvDefaults }
+
+/**
+ * Handle a Course Builder HTTP request.
+ *
+ * @param request - Web-standard request to route.
+ * @param config - Course Builder server runtime configuration.
+ * @returns The web-standard response produced by the selected action.
+ */
+export async function CourseBuilder(
+	request: Request,
+	config: CourseBuilderConfig,
+): Promise<Response> {
+	setLogger(config.logger, config.debug)
+
+	const internalRequest = await toInternalRequest(request, config)
+	if (!internalRequest) {
+		return Response.json('Bad request', { status: 400 })
+	}
+
+	const warningsOrError = assertConfig(internalRequest, config)
+
+	if (Array.isArray(warningsOrError)) {
+		warningsOrError.forEach((code) => logger.warn(code))
+	} else if (warningsOrError) {
+		logger.error(warningsOrError)
+		return Response.json('Internal Server Error', { status: 500 })
+	}
+	const isRedirect = request.headers?.has('X-Course-Builder-Return-Redirect')
+
+	try {
+		const internalResponse = await CourseBuilderInternal(
+			internalRequest,
+			config,
+		)
+
+		const response = toResponse(internalResponse)
+		const url = response.headers.get('Location')
+		if (!isRedirect || !url) return response
+
+		return Response.json({ url }, { headers: response.headers })
+	} catch (e) {
+		logger.error(e as Error)
+		if (request.method === 'POST' && internalRequest.action === 'session')
+			return Response.json(null, { status: 400 })
+		return Response.json(`something broke: ${(e as Error).message}`, {
+			status: 400,
+		})
+	}
+}
+
+/** Runtime configuration consumed by the server-owned HTTP entry point. */
+export interface CourseBuilderConfig {
+	callbacks?: Partial<CallbacksOptions>
+	adapter?: ServerAdapter
+	providers: Provider[]
+	debug?: boolean
+	basePath?: string
+	logger?: LoggerInstance
+	cookies?: Partial<CookiesOptions>
+	useSecureCookies?: boolean
+	inngest?: Inngest
+	getCurrentUser?: () => Promise<User | null>
+	authConfig: CourseBuilderAuthConfig
+	baseUrl: string
+}

package/src/index.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+	coreInngest,
+	courseBuilderCoreFunctions,
+	createInngestMiddleware,
+} from './index'
+
+describe('@coursebuilder/server Inngest composition', () => {
+	it('preserves the frozen core client and function aggregate', () => {
+		expect(coreInngest.id).toBe('core-inngest')
+		expect(courseBuilderCoreFunctions).toHaveLength(16)
+		expect(courseBuilderCoreFunctions[0]?.config.id).toBe(
+			'transcript-ready-event',
+		)
+	})
+
+	it('exports middleware construction from the package root', () => {
+		expect(createInngestMiddleware).toBeTypeOf('function')
+	})
+})

package/src/index.ts

@@ -0,0 +1,44 @@
+import {
+	commerceFunctionsAfterResourceChat,
+	commerceFunctionsBeforeResourceChat,
+} from '@coursebuilder/commerce/functions'
+import {
+	PURCHASE_BENEFITS_ATTACHED_EVENT,
+	TEAM_SEAT_REDEMPTION_CREATED_EVENT,
+} from '@coursebuilder/core/events/commerce'
+import { resourceChat } from './resource-chat'
+import { coreVideoProcessingFunctions } from '@coursebuilder/video-processing/functions'
+
+import { defineCourseBuilderFunctions } from './create-inngest-middleware'
+
+export { CourseBuilder, createActionURL, setEnvDefaults } from './http'
+export type { CourseBuilderConfig } from './http'
+export { CourseBuilderInternal } from './http-router'
+
+/** @deprecated Import this provider-neutral event map from `@coursebuilder/core/events`. */
+export type CourseBuilderCoreEvents =
+	import('@coursebuilder/core/events').CourseBuilderCoreEvents
+
+export { PURCHASE_BENEFITS_ATTACHED_EVENT, TEAM_SEAT_REDEMPTION_CREATED_EVENT }
+
+export const courseBuilderCoreFunctions = defineCourseBuilderFunctions([
+	...coreVideoProcessingFunctions,
+	...commerceFunctionsBeforeResourceChat,
+	resourceChat,
+	...commerceFunctionsAfterResourceChat,
+])
+
+export {
+	coreInngest,
+	createInngestMiddleware,
+	defineCourseBuilderFunctions,
+} from './create-inngest-middleware'
+export type {
+	CoreInngest,
+	CoreInngestContext,
+	CourseBuilderFunctionDefinition,
+	CourseBuilderHandlerInput,
+	CoreInngestFunctionInput,
+	CoreInngestHandler,
+	CoreInngestTrigger,
+} from './create-inngest-middleware'

package/src/mock-adapter.ts

@@ -0,0 +1,398 @@
+import {
+	ContentResourceResource,
+	Entitlement,
+	MerchantCharge,
+	UpgradableProduct,
+} from '@coursebuilder/core/schemas'
+import { AttributionSnapshotPayload } from '@coursebuilder/core/schemas/attribution-snapshot'
+import { type ContentResource } from '@coursebuilder/core/schemas/content-resource-schema'
+import { Coupon } from '@coursebuilder/core/schemas/coupon-schema'
+import { MerchantCoupon } from '@coursebuilder/core/schemas/merchant-coupon-schema'
+import { MerchantCustomer } from '@coursebuilder/core/schemas/merchant-customer-schema'
+import { MerchantEvents } from '@coursebuilder/core/schemas/merchant-events-schema'
+import { MerchantProduct } from '@coursebuilder/core/schemas/merchant-product-schema'
+import { MerchantSession } from '@coursebuilder/core/schemas/merchant-session'
+import { Price } from '@coursebuilder/core/schemas/price-schema'
+import { Product } from '@coursebuilder/core/schemas/product-schema'
+import { Purchase } from '@coursebuilder/core/schemas/purchase-schema'
+import {
+	PurchaseUserTransfer,
+	PurchaseUserTransferState,
+} from '@coursebuilder/core/schemas/purchase-user-transfer-schema'
+import {
+	ModuleProgress,
+	ResourceProgress,
+} from '@coursebuilder/core/schemas/resource-progress-schema'
+import { User } from '@coursebuilder/core/schemas/user-schema'
+
+import type { ServerAdapter } from './adapter'
+
+export const mockServerAdapter: ServerAdapter = {
+	client: null,
+	getPersonalOrganization: async () => null,
+	createPersonalOrganization: async () => {
+		throw new Error('Method not implemented.')
+	},
+	transferPurchaseToUser: async () => {
+		return null
+	},
+	redeemFullPriceCoupon: async () => {
+		return {} as any
+	},
+	archiveProduct: async (productId) => {
+		return {} as any
+	},
+	updateProduct: async (product) => {
+		return {} as any
+	},
+	createProduct: async (product) => {
+		return {} as any
+	},
+	createPurchaseTransfer: async () => {
+		return Promise.resolve()
+	},
+	createCoupon: async (input) => {
+		return []
+	},
+	addResourceToProduct: async (options) => {
+		return null
+	},
+	incrementCouponUsedCount(_) {
+		return Promise.resolve()
+	},
+	getExistingNonBulkValidPurchasesOfProduct: async () => {
+		return []
+	},
+	getMerchantPriceForProductId: async (productId) => null,
+	getMerchantProductForProductId: async (productId) => null,
+	getMerchantAccount: async () => null,
+	createMerchantCustomer: async () => null,
+	createMerchantCoupon: async () => ({}) as MerchantCoupon,
+	getMerchantCustomerForUserId: async () => null,
+	getUpgradableProducts: async () => [],
+	createPurchase: async (options) => {
+		throw new Error('Method not implemented.')
+	},
+	availableUpgradesForProduct(
+		purchases: any,
+		productId: string,
+	): Promise<
+		{
+			upgradableTo: { id: string; name: string }
+			upgradableFrom: { id: string; name: string }
+		}[]
+	> {
+		return Promise.resolve([])
+	},
+	clearLessonProgressForUser(options: {
+		userId: string
+		lessons: { id: string; slug: string }[]
+	}): Promise<void> {
+		return Promise.resolve(undefined)
+	},
+	completeLessonProgressForUser(options: {
+		userId: string
+		lessonId?: string
+	}): Promise<ResourceProgress | null> {
+		return Promise.resolve(null)
+	},
+	couponForIdOrCode(options: {
+		code?: string
+		couponId?: string
+	}): Promise<(Coupon & { merchantCoupon: MerchantCoupon }) | null> {
+		return Promise.resolve(null)
+	},
+	createMerchantChargeAndPurchase(options: {
+		userId: string
+		productId: string
+		stripeChargeId: string
+		stripeCouponId?: string
+		merchantAccountId: string
+		merchantProductId: string
+		merchantCustomerId: string
+		stripeChargeAmount: number
+		quantity?: number
+		bulk?: boolean
+		checkoutSessionId: string
+		appliedPPPStripeCouponId?: string
+		upgradedFromPurchaseId?: string
+		usedCouponId?: string
+		country?: string
+		organizationId?: string
+		purchaseBenefitsTransport?: string
+		attributionSnapshot?: AttributionSnapshotPayload
+	}): Promise<Purchase> {
+		throw new Error('Method not implemented.')
+	},
+	findOrCreateMerchantCustomer(options: {
+		user: User
+		identifier: string
+		merchantAccountId: string
+	}): Promise<MerchantCustomer | null> {
+		return Promise.resolve(null)
+	},
+	createMerchantEvent(options: {
+		merchantAccountId: string
+		identifier: string
+		payload: Record<string, any>
+	}): Promise<MerchantEvents> {
+		throw new Error('Method not implemented.')
+	},
+	getMerchantEventByIdentifier(
+		identifier: string,
+	): Promise<MerchantEvents | null> {
+		return Promise.resolve(null)
+	},
+	getMerchantEventsByAccount(
+		merchantAccountId: string,
+	): Promise<MerchantEvents[]> {
+		return Promise.resolve([])
+	},
+	findOrCreateUser(
+		email: string,
+		name?: string | null,
+	): Promise<{
+		user: User
+		isNewUser: boolean
+	}> {
+		throw new Error('Method not implemented.')
+	},
+	getCoupon(couponIdOrCode: string): Promise<Coupon | null> {
+		return Promise.resolve(null)
+	},
+	getCouponWithBulkPurchases(couponId: string): Promise<
+		| (Coupon & {
+				redeemedBulkCouponPurchases: Purchase[]
+				bulkPurchase?: Purchase | null
+		  })
+		| null
+	> {
+		return Promise.resolve(null)
+	},
+	getDefaultCoupon(productIds?: string[]): Promise<{
+		defaultMerchantCoupon: MerchantCoupon
+		defaultCoupon: Coupon
+	} | null> {
+		return Promise.resolve(null)
+	},
+	getLessonProgressCountsByDate(): Promise<
+		{
+			count: number
+			completedAt: string
+		}[]
+	> {
+		return Promise.resolve([])
+	},
+	getLessonProgressForUser(userId: string): Promise<ResourceProgress[]> {
+		return Promise.resolve([])
+	},
+	getModuleProgressForUser(
+		userId: string,
+		moduleId: string,
+	): Promise<ModuleProgress> {
+		return Promise.resolve({
+			completedLessons: [],
+			nextResource: null,
+			percentCompleted: 0,
+			completedLessonsCount: 0,
+			totalLessonsCount: 0,
+		})
+	},
+	getLessonProgresses(): Promise<ResourceProgress[]> {
+		return Promise.resolve([])
+	},
+	getMerchantCharge(merchantChargeId: string): Promise<MerchantCharge | null> {
+		return Promise.resolve(null)
+	},
+	getMerchantCouponForTypeAndPercent(params: {
+		type: string
+		percentageDiscount: number
+	}): Promise<MerchantCoupon | null> {
+		return Promise.resolve(null)
+	},
+	getMerchantCouponsForTypeAndPercent(params: {
+		type: string
+		percentageDiscount: number
+	}): Promise<MerchantCoupon[]> {
+		return Promise.resolve([])
+	},
+	getMerchantCouponForTypeAndAmount(params: {
+		type: string
+		amountDiscount: number
+	}): Promise<MerchantCoupon | null> {
+		return Promise.resolve(null)
+	},
+	getMerchantCoupon(merchantCouponId: string): Promise<MerchantCoupon | null> {
+		return Promise.resolve(null)
+	},
+	getMerchantProduct(stripeProductId: string): Promise<MerchantProduct | null> {
+		return Promise.resolve(null)
+	},
+	getPrice(productId: string): Promise<Price | null> {
+		return Promise.resolve(null)
+	},
+	getPriceForProduct(productId: string): Promise<Price | null> {
+		return Promise.resolve(null)
+	},
+	getProduct(
+		productId?: string,
+		withResources: boolean = true,
+	): Promise<Product | null> {
+		return Promise.resolve(null)
+	},
+	getProductResources(productId: string): Promise<ContentResource[] | null> {
+		return Promise.resolve(null)
+	},
+	getPurchaseCountForProduct(productId: string): Promise<number> {
+		return Promise.resolve(0)
+	},
+	getPurchase(purchaseId: string): Promise<Purchase | null> {
+		return Promise.resolve(null)
+	},
+	getPurchaseDetails(
+		purchaseId: string,
+		userId: string,
+	): Promise<{
+		purchase?: Purchase
+		existingPurchase?: Purchase | null
+		availableUpgrades: UpgradableProduct[]
+	}> {
+		return Promise.resolve({ availableUpgrades: [] })
+	},
+	getPurchaseForStripeCharge(stripeChargeId: string): Promise<Purchase | null> {
+		return Promise.resolve(null)
+	},
+	getPurchaseByCheckoutSessionId(
+		checkoutSessionId: string,
+	): Promise<Purchase | null> {
+		return Promise.resolve(null)
+	},
+	getPurchaseUserTransferById(options: { id: string }): Promise<
+		| (PurchaseUserTransfer & {
+				sourceUser: User
+				targetUser: User | null
+				purchase: Purchase
+		  })
+		| null
+	> {
+		return Promise.resolve(null)
+	},
+	getPurchaseWithUser(purchaseId: string): Promise<
+		| (Purchase & {
+				user: User
+		  })
+		| null
+	> {
+		return Promise.resolve(null)
+	},
+	getUserWithPurchasersByEmail(email: string): Promise<any | null> {
+		return Promise.resolve(null)
+	},
+	getPurchasesForUser(userId?: string): Promise<Purchase[]> {
+		return Promise.resolve([])
+	},
+	getEntitlementsForUser(params: {
+		userId: string
+		sourceType?: string
+		entitlementType?: string
+	}): Promise<Entitlement[]> {
+		return Promise.resolve([])
+	},
+	getEntitlementTypeByName(
+		name: string,
+	): Promise<{ id: string; name: string } | null> {
+		return Promise.resolve(null)
+	},
+	getUserById(userId: string): Promise<User | null> {
+		return Promise.resolve(null)
+	},
+	pricesOfPurchasesTowardOneBundle(options: {
+		userId: string | undefined
+		bundleId: string
+	}): Promise<Price[]> {
+		return Promise.resolve([])
+	},
+	toggleLessonProgressForUser(options: {
+		userId: string
+		lessonId?: string
+		lessonSlug?: string
+	}): Promise<ResourceProgress | null> {
+		return Promise.resolve(null)
+	},
+	transferPurchasesToNewUser(options: {
+		merchantCustomerId: string
+		userId: string
+	}): Promise<unknown> {
+		return Promise.resolve(undefined)
+	},
+	updatePurchaseStatusForCharge(
+		chargeId: string,
+		status: 'Valid' | 'Refunded' | 'Disputed' | 'Banned' | 'Restricted',
+	): Promise<Purchase | undefined> {
+		return Promise.resolve(undefined)
+	},
+	updatePurchaseUserTransferTransferState(options: {
+		id: string
+		transferState: PurchaseUserTransferState
+	}): Promise<PurchaseUserTransfer | null> {
+		return Promise.resolve(null)
+	},
+	addResourceToResource: async (options) => {
+		return {} as ContentResourceResource
+	},
+	removeResourceFromResource: async (options) => {
+		return null
+	},
+	createContentResource: async (resource) => {
+		return resource as ContentResource
+	},
+	getEvent: async (_) => {
+		return null
+	},
+	createEvent: async (_) => {
+		return null
+	},
+	createEventSeries: async (_) => {
+		return { eventSeries: null as any, childEvents: [] }
+	},
+	createCohort: async (_) => {
+		return { cohort: null as any, product: undefined }
+	},
+	createWorkshop: async (_) => {
+		return {
+			workshop: null as any,
+			sections: [],
+			lessons: [],
+			product: undefined,
+		}
+	},
+	getContentResource: async (_) => {
+		return null
+	},
+	getVideoResource: async (_) => {
+		return null
+	},
+	getParentResourceOfVideoResource: async (_) => {
+		return null
+	},
+	updateContentResourceFields(_) {
+		return null
+	},
+	createOrganization: async () => null,
+	getOrganization: async () => null,
+	addMemberToOrganization: async () => null,
+	removeMemberFromOrganization: async () => undefined,
+	addRoleForMember: async () => undefined,
+	removeRoleForMember: async () => undefined,
+	getMembershipsForUser: async () => [],
+	getOrganizationMembers: async () => [],
+	getMerchantSubscription: async () => null,
+	createMerchantSubscription: async () => null,
+	updateMerchantSubscription: async () => null,
+	deleteMerchantSubscription: async () => undefined,
+	createMerchantSession: async () => Promise.resolve({} as MerchantSession),
+	createSubscription: async () => null,
+	getSubscriptionForStripeId: async () => null,
+	updateSubscriptionStatus: async () => undefined,
+	getPurchasesForBulkCouponId: async () => [],
+}

package/src/mock-payment-provider.ts

@@ -0,0 +1,56 @@
+import type {
+	PaymentsAdapter,
+	PaymentsProviderConfig,
+} from '@coursebuilder/core/types'
+
+const mockPaymentsAdapter: PaymentsAdapter = {
+	getCouponPercentOff: async () => 0,
+	getCouponAmountOff: async () => 0,
+	createCoupon: async () => 'mock-coupon-id',
+	createPromotionCode: async () => 'mock-promotion-code-id',
+	createCheckoutSession: async () => 'mock-checkout-session-id',
+	createCustomer: async () => 'mock-customer-id',
+	verifyWebhookSignature: async () => true,
+	getCheckoutSession: async () => ({ id: 'mock-checkout-session-id' }) as any,
+	getCustomer: async () => ({ id: 'mock-customer-id' }) as any,
+	updateCustomer: async () => {},
+	refundCharge: async () => ({}) as any,
+	updateProduct: async () => {},
+	updatePrice: async () => {},
+	getProduct: async () => ({}) as any,
+	getPrice: async () => ({}) as any,
+	createPrice: async () => ({}) as any,
+	createProduct: async () => ({}) as any,
+	getSubscription: async () => ({}) as any,
+	getBillingPortalUrl: async () => 'mock-billing-portal-url',
+	updateSubscriptionItemQuantity: async () => ({}) as any,
+}
+
+export const mockPaymentProvider: PaymentsProviderConfig = {
+	id: 'mock-stripe',
+	name: 'Mock Stripe',
+	type: 'payment',
+	options: {
+		errorRedirectUrl: 'mock-error-redirect-url',
+		cancelUrl: 'mock-cancel-url',
+		baseSuccessUrl: 'mock-base-success-url',
+		paymentsAdapter: mockPaymentsAdapter,
+	},
+	getSubscriptionInfo: async () => ({}) as any,
+	getPurchaseInfo: async () => ({}) as any,
+	createCheckoutSession: async () => ({
+		redirect: 'mock-checkout-session-id',
+		status: 303,
+	}),
+	getCustomer: async () => ({ id: 'mock-customer-id' }) as any,
+	updateCustomer: async () => {},
+	refundCharge: async () => ({}) as any,
+	updateProduct: async () => {},
+	updatePrice: async () => {},
+	getProduct: async () => ({}) as any,
+	getPrice: async () => ({}) as any,
+	createPrice: async () => ({}) as any,
+	createProduct: async () => ({}) as any,
+	getSubscription: async () => ({}) as any,
+	getBillingPortalUrl: async () => 'mock-billing-portal-url',
+}