@coursebuilder/server 0.1.0-canary.0.0c9beb2ae

package/dist/runtime/init.d.ts

@@ -0,0 +1,26 @@
+import { CallbacksOptions, InternalOptions, RequestInternal } from '@coursebuilder/core/types';
+import { CourseBuilderConfig } from '../http.js';
+import { Cookie } from './cookie.js';
+import 'inngest';
+import '../adapter-BtDS6LDw.js';
+import '@coursebuilder/core/auth';
+import '@coursebuilder/core/ports';
+import '@coursebuilder/core/providers';
+import '@coursebuilder/core/schemas';
+import '@coursebuilder/utils/logger';
+
+interface InitParams {
+    url: URL;
+    courseBuilderOptions: CourseBuilderConfig;
+    providerId?: string;
+    action: InternalOptions['action'];
+    isPost: boolean;
+    cookies: RequestInternal['cookies'];
+}
+declare function init({ url, courseBuilderOptions, providerId, action, isPost, cookies: reqCookies, }: InitParams): Promise<{
+    options: InternalOptions;
+    cookies: Cookie[];
+}>;
+declare const defaultCallbacks: CallbacksOptions;
+
+export { defaultCallbacks, init };

package/dist/runtime/init.js

@@ -0,0 +1,14 @@
+import {
+  defaultCallbacks,
+  init
+} from "../chunk-5O4UO4IR.js";
+import "../chunk-W7YAT4NR.js";
+import "../chunk-4QQA3TC2.js";
+import "../chunk-KNC7QVGZ.js";
+import "../chunk-AZLUMIIF.js";
+import "../chunk-WGAPYIUP.js";
+export {
+  defaultCallbacks,
+  init
+};
+//# sourceMappingURL=init.js.map

package/dist/runtime/init.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/runtime/logger.d.ts

@@ -0,0 +1,4 @@
+export { LogAttributes, LoggerInstance, WarningCode, logger, setLogger } from '@coursebuilder/utils/logger';
+import '@coursebuilder/commerce/process-refund';
+import '@coursebuilder/commerce/redeem';
+import '@coursebuilder/commerce/transfer-purchase';

package/dist/runtime/logger.js

@@ -0,0 +1,10 @@
+import {
+  logger,
+  setLogger
+} from "../chunk-AZLUMIIF.js";
+import "../chunk-WGAPYIUP.js";
+export {
+  logger,
+  setLogger
+};
+//# sourceMappingURL=logger.js.map

package/dist/runtime/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/runtime/merge.d.ts

@@ -0,0 +1,4 @@
+/** Deep merge two objects */
+declare function merge(target: any, ...sources: any[]): any;
+
+export { merge };

package/dist/runtime/merge.js

@@ -0,0 +1,8 @@
+import {
+  merge
+} from "../chunk-KNC7QVGZ.js";
+import "../chunk-WGAPYIUP.js";
+export {
+  merge
+};
+//# sourceMappingURL=merge.js.map

package/dist/runtime/merge.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/runtime/providers.d.ts

@@ -0,0 +1,21 @@
+import { Provider } from '@coursebuilder/core/providers';
+import { InternalProvider } from '@coursebuilder/core/types';
+import { CourseBuilderConfig } from '../http.js';
+import 'inngest';
+import '../adapter-BtDS6LDw.js';
+import '@coursebuilder/core/auth';
+import '@coursebuilder/core/ports';
+import '@coursebuilder/core/schemas';
+import '@coursebuilder/utils/logger';
+
+declare function parseProviders(params: {
+    providers: Provider[];
+    url: URL;
+    providerId?: string;
+    options: CourseBuilderConfig;
+}): {
+    providers: InternalProvider[];
+    provider?: InternalProvider;
+};
+
+export { parseProviders as default };

package/dist/runtime/providers.js

@@ -0,0 +1,9 @@
+import {
+  parseProviders
+} from "../chunk-4QQA3TC2.js";
+import "../chunk-KNC7QVGZ.js";
+import "../chunk-WGAPYIUP.js";
+export {
+  parseProviders as default
+};
+//# sourceMappingURL=providers.js.map

package/dist/runtime/providers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/runtime/web.d.ts

@@ -0,0 +1,29 @@
+import { CourseBuilderError } from '@coursebuilder/core/errors';
+import { CourseBuilderAction, RequestInternal, ResponseInternal } from '@coursebuilder/core/types';
+import { CourseBuilderConfig } from '../http.js';
+import 'inngest';
+import '../adapter-BtDS6LDw.js';
+import '@coursebuilder/core/auth';
+import '@coursebuilder/core/ports';
+import '@coursebuilder/core/providers';
+import '@coursebuilder/core/schemas';
+import '@coursebuilder/utils/logger';
+
+/**
+ * takes a `Request` object and converts it into an internal request object
+ * that we use throughout the system
+ * @param req
+ * @param config
+ * @returns
+ */
+declare function toInternalRequest(req: Request, config: CourseBuilderConfig): Promise<RequestInternal | undefined>;
+declare function parseActionAndProviderId(pathname: string, base: string): {
+    action: CourseBuilderAction;
+    providerId?: string;
+};
+declare class UnknownAction extends CourseBuilderError {
+    static type: string;
+}
+declare function toResponse(res: ResponseInternal): Response;
+
+export { UnknownAction, parseActionAndProviderId, toInternalRequest, toResponse };

package/dist/runtime/web.js

@@ -0,0 +1,16 @@
+import {
+  UnknownAction,
+  parseActionAndProviderId,
+  toInternalRequest,
+  toResponse
+} from "../chunk-4TSEPUSC.js";
+import "../chunk-VEKYIR7I.js";
+import "../chunk-AZLUMIIF.js";
+import "../chunk-WGAPYIUP.js";
+export {
+  UnknownAction,
+  parseActionAndProviderId,
+  toInternalRequest,
+  toResponse
+};
+//# sourceMappingURL=web.js.map

package/dist/runtime/web.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@coursebuilder/server",
+  "version": "0.1.0-canary.0.0c9beb2ae",
+  "private": false,
+  "description": "Server-side composition root for Course Builder",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./create-inngest-middleware": {
+      "types": "./dist/create-inngest-middleware.d.ts",
+      "import": "./dist/create-inngest-middleware.js"
+    },
+    "./http": {
+      "types": "./dist/http.d.ts",
+      "import": "./dist/http.js"
+    },
+    "./http-router": {
+      "types": "./dist/http-router.d.ts",
+      "import": "./dist/http-router.js"
+    },
+    "./actions/*": {
+      "types": "./dist/actions/*.d.ts",
+      "import": "./dist/actions/*.js"
+    },
+    "./runtime/*": {
+      "types": "./dist/runtime/*.d.ts",
+      "import": "./dist/runtime/*.js"
+    }
+  },
+  "dependencies": {
+    "ai": "5.0.116",
+    "cookie": "0.7.0",
+    "date-fns": "^2.30.0",
+    "inngest": "3.54.2",
+    "liquidjs": "^10.21.0",
+    "zod": "^4.1.12",
+    "@coursebuilder/commerce": "0.1.0-canary.0.0c9beb2ae",
+    "@coursebuilder/email": "0.1.0-canary.0.0c9beb2ae",
+    "@coursebuilder/core": "3.0.0-canary.0.0c9beb2ae",
+    "@coursebuilder/nodash": "0.0.3",
+    "@coursebuilder/utils": "1.1.0-canary.0.0c9beb2ae",
+    "@coursebuilder/video-processing": "0.1.0-canary.0.0c9beb2ae"
+  },
+  "devDependencies": {
+    "@types/cookie": "0.6.0",
+    "tsup": "8.0.2",
+    "typescript": "5.4.5",
+    "vitest": "1.6.0"
+  },
+  "peerDependencies": {},
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/actions/actions.test.ts

@@ -0,0 +1,232 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import {
+	processRefund as commerceProcessRefund,
+	redeem as commerceRedeem,
+	transferPurchase as commerceTransferPurchase,
+} from '@coursebuilder/commerce'
+import { checkout as legacyCheckout } from '@coursebuilder/server/actions/checkout'
+import { webhook as legacyWebhook } from '@coursebuilder/server/actions/index'
+import type {
+	InternalOptions,
+	RequestInternal,
+} from '@coursebuilder/core/types'
+
+import { checkout } from './checkout'
+import { claimed } from './claimed'
+import { createMagicLink } from './create-magic-link'
+import { getUserPurchases, session, webhook } from './index'
+import { processRefund } from './process-refund'
+import { redeem } from './redeem'
+import { transferPurchase } from './transfer-purchase'
+import { userLookup } from './user-lookup'
+
+const cookies = [{ name: 'session', value: 'cookie', options: {} }]
+
+const request = (overrides: Partial<RequestInternal> = {}): RequestInternal =>
+	({
+		action: 'session',
+		method: 'GET',
+		url: new URL('http://test.com/api/coursebuilder/session'),
+		cookies: {},
+		headers: {},
+		query: {},
+		...overrides,
+	}) as RequestInternal
+
+describe('@coursebuilder/server HTTP actions', () => {
+	it('keeps commerce operations behind their engine boundary', () => {
+		expect(processRefund).toBe(commerceProcessRefund)
+		expect(redeem).toBe(commerceRedeem)
+		expect(transferPurchase).toBe(commerceTransferPurchase)
+	})
+
+	it('preserves the session callback response contract', async () => {
+		const options = {
+			callbacks: {
+				session: vi.fn().mockResolvedValue({ user: { id: 'user-1' } }),
+			},
+			logger: { error: vi.fn() },
+		} as unknown as InternalOptions
+
+		await expect(session(options, cookies)).resolves.toEqual({
+			body: { user: { id: 'user-1' } },
+			headers: { 'Content-Type': 'application/json' },
+			cookies,
+		})
+	})
+
+	it('preserves authenticated purchase lookup behavior', async () => {
+		const purchases = [{ id: 'purchase-1' }]
+		const options = {
+			adapter: { getPurchasesForUser: vi.fn().mockResolvedValue(purchases) },
+			getCurrentUser: vi.fn().mockResolvedValue({ id: 'user-1' }),
+		} as unknown as InternalOptions
+
+		await expect(
+			getUserPurchases(
+				request({ query: { userId: 'user-1' } }),
+				cookies,
+				options,
+			),
+		).resolves.toEqual({
+			status: 200,
+			body: purchases,
+			headers: { 'Content-Type': 'application/json' },
+			cookies,
+		})
+	})
+
+	it('preserves checkout redirects across the compatibility boundary', async () => {
+		const checkoutRequest = request({
+			action: 'checkout',
+			method: 'POST',
+			query: {
+				productId: 'product-1',
+				cancelUrl: 'http://test.com/cancel',
+				bulk: 'false',
+			},
+		})
+		const createOptions = () =>
+			({
+				provider: {
+					createCheckoutSession: vi
+						.fn()
+						.mockResolvedValue({ redirect: 'https://checkout.test/session' }),
+				},
+				adapter: {
+					getProduct: vi.fn().mockResolvedValue({ type: 'course' }),
+				},
+				baseUrl: 'http://test.com',
+			}) as unknown as InternalOptions<'payment'>
+
+		const legacyResponse = await legacyCheckout(
+			checkoutRequest,
+			cookies,
+			createOptions(),
+		)
+		const serverResponse = await checkout(
+			checkoutRequest,
+			cookies,
+			createOptions(),
+		)
+
+		expect({
+			status: (serverResponse as Response).status,
+			location: (serverResponse as Response).headers.get('location'),
+		}).toEqual({
+			status: (legacyResponse as Response).status,
+			location: (legacyResponse as Response).headers.get('location'),
+		})
+	})
+
+	it('preserves transcription webhook persistence and response behavior', async () => {
+		const results = {
+			channels: [
+				{
+					alternatives: [
+						{
+							transcript: 'Hello',
+							words: [
+								{
+									word: 'hello',
+									punctuated_word: 'Hello.',
+									start: 0,
+									end: 1,
+									confidence: 1,
+								},
+							],
+						},
+					],
+				},
+			],
+		}
+		const webhookRequest = request({
+			action: 'webhook',
+			method: 'POST',
+			body: { results },
+		})
+		const createOptions = () => {
+			const adapter = {
+				getContentResource: vi
+					.fn()
+					.mockResolvedValueOnce({ id: 'video-1', createdById: 'user-1' })
+					.mockResolvedValueOnce(null),
+				createContentResource: vi.fn(),
+				addResourceToResource: vi.fn(),
+				updateContentResourceFields: vi.fn(),
+			}
+			return {
+				options: {
+					provider: { type: 'transcription' },
+					adapter,
+					inngest: { send: vi.fn() },
+					url: new URL('http://test.com/webhook?videoResourceId=video-1'),
+				} as unknown as InternalOptions<'transcription'>,
+				adapter,
+			}
+		}
+		const legacy = createOptions()
+		const server = createOptions()
+
+		const legacyResponse = await legacyWebhook(
+			webhookRequest,
+			cookies,
+			legacy.options,
+		)
+		const serverResponse = await webhook(
+			webhookRequest,
+			cookies,
+			server.options,
+		)
+
+		expect(serverResponse).toEqual(legacyResponse)
+		expect(server.adapter.updateContentResourceFields.mock.calls).toEqual(
+			legacy.adapter.updateContentResourceFields.mock.calls,
+		)
+	})
+
+	it('preserves claimed-seat projection behavior', async () => {
+		const options = {
+			adapter: {
+				getPurchasesForBulkCouponId: vi
+					.fn()
+					.mockResolvedValue([
+						{ user: { name: 'Ada', email: 'ada@example.com' } },
+					]),
+			},
+		} as unknown as InternalOptions
+
+		await expect(
+			claimed(
+				request({ body: { bulkCouponId: 'coupon-1' } }),
+				cookies,
+				options,
+			),
+		).resolves.toEqual({
+			body: [{ name: 'Ada', email: 'ada@example.com' }],
+			headers: { 'Content-Type': 'application/json' },
+			cookies,
+		})
+	})
+
+	it.each([
+		['lookup', userLookup],
+		['create-magic-link', createMagicLink],
+	] as const)('preserves secret protection for %s', async (action, handler) => {
+		vi.stubEnv('SKILL_SECRET', 'expected-secret')
+		const options = { adapter: {} } as InternalOptions
+		await expect(
+			handler(
+				request({
+					action,
+					method: 'POST',
+					headers: { 'x-skill-secret': 'wrong-secret' },
+					body: {},
+				}),
+				cookies,
+				options,
+			),
+		).resolves.toEqual({ status: 401, body: 'unauthorized' })
+	})
+})

package/src/actions/checkout.ts

@@ -0,0 +1,160 @@
+import { buildCheckoutAttribution } from '@coursebuilder/commerce/checkout-attribution'
+import { CheckoutParamsSchema } from '@coursebuilder/commerce/stripe-checkout'
+import type {
+	InternalOptions,
+	RequestInternal,
+	ResponseInternal,
+} from '@coursebuilder/core/types'
+
+import type { Cookie } from '../runtime/cookie'
+import { logger } from '../runtime/logger'
+
+const searchParamsWithoutNil = (params: Record<string, unknown>) => {
+	return new URLSearchParams(
+		Object.entries(params).flatMap(([key, value]) => {
+			if (value === undefined || value === null) return []
+			return [[key, String(value)]]
+		}),
+	)
+}
+
+export async function checkout(
+	request: RequestInternal,
+	cookies: Cookie[],
+	options: InternalOptions<'payment'>,
+): Promise<ResponseInternal> {
+	const response: ResponseInternal<any | null> = {
+		body: null,
+		headers: { 'Content-Type': 'application/json' },
+		cookies,
+	}
+
+	// Extract shortlink reference from cookie
+	const shortlinkRefCookie = cookies.find((c) => c.name === 'sl_ref')
+	const shortlinkRef = shortlinkRefCookie?.value
+
+	// Extract first-touch attribution from cookie
+	const ftAttrCookie = cookies.find((c) => c.name === 'ft_attr')
+	let firstTouch: Record<string, unknown> = {}
+	try {
+		if (ftAttrCookie?.value) {
+			firstTouch = JSON.parse(decodeURIComponent(ftAttrCookie.value))
+		}
+	} catch {
+		// Malformed cookie, ignore
+	}
+
+	// Extract last-touch attribution from cookie
+	const ltAttrCookie = cookies.find((c) => c.name === 'lt_attr')
+	let lastTouch: Record<string, string> = {}
+	try {
+		if (ltAttrCookie?.value) {
+			lastTouch = JSON.parse(decodeURIComponent(ltAttrCookie.value))
+		}
+	} catch {
+		// Malformed cookie, ignore
+	}
+
+	const selfReportedSource =
+		typeof request.query?.selfReportedSource === 'string'
+			? request.query.selfReportedSource.slice(0, 500)
+			: undefined
+	const checkoutAttribution = buildCheckoutAttribution({
+		firstTouch,
+		lastTouch,
+		shortlinkRef,
+		selfReportedSource,
+	})
+
+	logger.debug('checkout.cookies-received', {
+		cookieCount: cookies.length,
+		cookieNames: cookies.map((c) => c.name),
+		hasShortlinkRef: Boolean(shortlinkRef),
+		hasAttributionSnapshot: Boolean(checkoutAttribution.attributionSnapshot),
+	})
+
+	const checkoutParamsParsed = CheckoutParamsSchema.safeParse({
+		...request.query,
+		country:
+			request.query?.country ||
+			request.headers?.['x-vercel-ip-country'] ||
+			process.env.DEFAULT_COUNTRY ||
+			'US',
+		ip_address:
+			request.query?.ip_address ||
+			request.headers?.['x-forwarded-for'] ||
+			'0.0.0.0',
+		organizationId: request.query?.organizationId,
+		...(selfReportedSource && { selfReportedSource }),
+		...checkoutAttribution,
+	})
+
+	if (!checkoutParamsParsed.success) {
+		const parseError = new Error('Error parsing checkout params')
+		logger.error(parseError, {
+			context: 'checkout.params-parse',
+			issueCount: checkoutParamsParsed.error.issues.length,
+			issuePaths: checkoutParamsParsed.error.issues.map((issue) =>
+				issue.path.join('.'),
+			),
+			productId:
+				typeof request.query?.productId === 'string'
+					? request.query.productId
+					: undefined,
+			organizationId:
+				typeof request.query?.organizationId === 'string'
+					? request.query.organizationId
+					: undefined,
+		})
+		throw new Error('Error parsing checkout params')
+	}
+
+	const checkoutParams = checkoutParamsParsed.data
+
+	try {
+		const stripe = await options.provider.createCheckoutSession(
+			checkoutParams,
+			options.adapter,
+		)
+
+		const product = await options.adapter?.getProduct(checkoutParams.productId)
+
+		// if the product is a membership or cohort, we need to redirect to the login page
+		// if the user isn't logged in. we want to ensure an org id is set.
+		if (
+			product?.type &&
+			['membership', 'cohort', 'cohort-archive', 'live'].includes(product.type)
+		) {
+			return Response.redirect(
+				`${options.baseUrl}/subscribe/verify-login?${searchParamsWithoutNil({
+					...request.query,
+					country:
+						request.query?.country ||
+						request.headers?.['x-vercel-ip-country'] ||
+						process.env.DEFAULT_COUNTRY ||
+						'US',
+					ip_address:
+						request.query?.ip_address ||
+						request.headers?.['x-forwarded-for'] ||
+						'0.0.0.0',
+					organizationId: request.query?.organizationId,
+					productId: checkoutParams.productId,
+					checkoutUrl: stripe.redirect,
+					cancelUrl: checkoutParams.cancelUrl,
+					selfReportedSource,
+				})}`,
+			)
+		}
+
+		return Response.redirect(stripe.redirect)
+	} catch (e) {
+		logger.error(e instanceof Error ? e : new Error(String(e)), {
+			context: 'checkout.create-session',
+			productId: checkoutParams.productId,
+			organizationId: checkoutParams.organizationId,
+			country: checkoutParams.country,
+		})
+	}
+
+	return response
+}

package/src/actions/claimed.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod'
+
+import type {
+	InternalOptions,
+	RequestInternal,
+	ResponseInternal,
+} from '@coursebuilder/core/types'
+
+import type { Cookie } from '../runtime/cookie'
+
+export async function claimed(
+	request: RequestInternal,
+	cookies: Cookie[],
+	options: InternalOptions,
+): Promise<ResponseInternal> {
+	if (!options.adapter) throw new Error('Adapter not found')
+
+	const bulkCouponId = z
+		.string()
+		.optional()
+		.parse(request.query?.bulkCouponId || request.body?.bulkCouponId)
+
+	if (!bulkCouponId) throw new Error('Bulk coupon ID is required')
+
+	const purchases =
+		await options.adapter.getPurchasesForBulkCouponId(bulkCouponId)
+
+	const users = purchases.map((purchase) => {
+		return {
+			name: purchase.user.name,
+			email: purchase.user.email,
+		}
+	})
+
+	return {
+		body: users,
+		headers: { 'Content-Type': 'application/json' },
+		cookies,
+	}
+}