npm - @ripple-ts/adapter-vercel - Versions diffs - 0.2.214 - Mend

@ripple-ts/adapter-vercel 0.2.214

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/src/bin/adapt.js ADDED Viewed

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for `ripple-adapt-vercel`.
+ *
+ * Runs the adapt() function to generate Vercel Build Output API v3
+ * from the Ripple build output.
+ *
+ * Usage:
+ *   ripple-adapt-vercel [--out-dir dist] [--runtime nodejs22.x] [--regions iad1,sfo1]
+ */
+import { adapt } from '../adapt.js';
+/**
+ * Parse simple CLI flags.
+ *
+ * @param {string[]} argv
+ * @returns {Record<string, string>}
+ */
+function parse_args(argv) {
+	/** @type {Record<string, string>} */
+	const args = {};
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg.startsWith('--')) {
+			const key = arg.slice(2);
+			const value = argv[i + 1];
+			if (value && !value.startsWith('--')) {
+				args[key] = value;
+				i++;
+			} else {
+				args[key] = 'true';
+			}
+		}
+	}
+	return args;
+}
+const args = parse_args(process.argv.slice(2));
+/** @type {import('@ripple-ts/adapter-vercel').AdaptOptions} */
+const options = {};
+if (args['out-dir']) {
+	options.outDir = args['out-dir'];
+}
+if (args['runtime'] || args['regions'] || args['memory'] || args['max-duration']) {
+	options.serverless = {};
+	if (args['runtime']) {
+		options.serverless.runtime = args['runtime'];
+	}
+	if (args['regions']) {
+		options.serverless.regions = args['regions'].split(',');
+	}
+	if (args['memory']) {
+		options.serverless.memory = Number(args['memory']);
+	}
+	if (args['max-duration']) {
+		options.serverless.maxDuration = Number(args['max-duration']);
+	}
+}
+try {
+	await adapt(options);
+} catch (error) {
+	console.error(error instanceof Error ? error.message : error);
+	process.exit(1);
+}

package/src/index.js ADDED Viewed

@@ -0,0 +1,10 @@
+/**
+ * @ripple-ts/adapter-vercel — Vercel adapter for the Ripple metaframework.
+ *
+ * Re-exports Node.js runtime primitives from @ripple-ts/adapter-node
+ * (Vercel Serverless Functions run on Node.js) and provides the `adapt()`
+ * function that generates Vercel's Build Output API v3 structure.
+ */
+export { runtime, serve } from '@ripple-ts/adapter-node';
+export { adapt } from './adapt.js';

package/tests/adapt.test.js ADDED Viewed

@@ -0,0 +1,435 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+// Mock @vercel/nft to avoid actual dependency tracing in unit tests
+vi.mock('@vercel/nft', () => ({
+	nodeFileTrace: vi.fn(async () => ({
+		fileList: new Set(),
+		warnings: [],
+	})),
+}));
+describe('adapt()', () => {
+	/** @type {string} */
+	let tmp_dir;
+	/** @type {string} */
+	let original_cwd;
+	beforeEach(() => {
+		tmp_dir = mkdtempSync(join(tmpdir(), 'ripple-adapter-vercel-'));
+		original_cwd = process.cwd();
+		process.chdir(tmp_dir);
+	});
+	afterEach(() => {
+		process.chdir(original_cwd);
+		rmSync(tmp_dir, { recursive: true, force: true });
+	});
+	/**
+	 * Create a minimal Ripple build output structure.
+	 *
+	 * @param {string} root
+	 * @param {{ outDir?: string }} [options]
+	 */
+	function create_build_output(root, options = {}) {
+		const { outDir = 'dist' } = options;
+		const build_dir = join(root, outDir);
+		// Client output
+		const client_dir = join(build_dir, 'client');
+		mkdirSync(join(client_dir, 'assets'), { recursive: true });
+		writeFileSync(join(client_dir, 'index.html'), '<!doctype html><html></html>');
+		writeFileSync(join(client_dir, 'assets', 'app.abc12345.js'), 'console.log("app")');
+		writeFileSync(join(client_dir, 'assets', 'style.def67890.css'), 'body{}');
+		// Server output
+		const server_dir = join(build_dir, 'server');
+		mkdirSync(server_dir, { recursive: true });
+		writeFileSync(
+			join(server_dir, 'entry.js'),
+			'export const handler = (req) => new Response("ok");',
+		);
+	}
+	it('throws when client build output is missing', async () => {
+		const { adapt } = await import('../src/adapt.js');
+		await expect(adapt()).rejects.toThrow('Client build output not found');
+	});
+	it('throws when server entry is missing', async () => {
+		const { adapt } = await import('../src/adapt.js');
+		const client_dir = join(tmp_dir, 'dist', 'client');
+		mkdirSync(client_dir, { recursive: true });
+		writeFileSync(join(client_dir, 'index.html'), '<html></html>');
+		await expect(adapt()).rejects.toThrow('Server entry not found');
+	});
+	it('generates .vercel/output/ structure', async () => {
+		const { adapt } = await import('../src/adapt.js');
+		create_build_output(tmp_dir);
+		await adapt();
+		const output_dir = join(tmp_dir, '.vercel', 'output');
+		// config.json exists
+		expect(existsSync(join(output_dir, 'config.json'))).toBe(true);
+		// Static directory exists with assets
+		expect(existsSync(join(output_dir, 'static', 'assets', 'app.abc12345.js'))).toBe(true);
+		expect(existsSync(join(output_dir, 'static', 'assets', 'style.def67890.css'))).toBe(true);
+		// index.html is removed from static (SSR handles root)
+		expect(existsSync(join(output_dir, 'static', 'index.html'))).toBe(false);
+		// Function directory exists
+		expect(existsSync(join(output_dir, 'functions', 'index.func'))).toBe(true);
+		expect(existsSync(join(output_dir, 'functions', 'index.func', 'index.js'))).toBe(true);
+		expect(existsSync(join(output_dir, 'functions', 'index.func', '.vc-config.json'))).toBe(true);
+		expect(existsSync(join(output_dir, 'functions', 'index.func', 'package.json'))).toBe(true);
+	});
+	it('generates valid config.json with Build Output API v3', async () => {
+		const { adapt } = await import('../src/adapt.js');
+		create_build_output(tmp_dir);
+		await adapt();
+		const config = JSON.parse(
+			readFileSync(join(tmp_dir, '.vercel', 'output', 'config.json'), 'utf-8'),
+		);
+		expect(config.version).toBe(3);
+		expect(config.cleanUrls).toBe(true);
+		expect(Array.isArray(config.routes)).toBe(true);
+		// Should have a filesystem handler
+		const filesystem_route = config.routes.find(
+			(/** @type {any} */ r) => r.handle === 'filesystem',
+		);
+		expect(filesystem_route).toBeTruthy();
+		// Should have a catch-all route to the serverless function
+		const catchall_route = config.routes.find((/** @type {any} */ r) => r.src === '/.*' && r.dest);
+		expect(catchall_route).toBeTruthy();
+		expect(catchall_route.dest).toBe('/index');
+		// Should have immutable cache header for assets
+		const asset_route = config.routes.find((/** @type {any} */ r) => r.src === '/assets/.+');
+		expect(asset_route).toBeTruthy();
+		expect(asset_route.headers['Cache-Control']).toContain('immutable');
+	});
+	it('generates valid .vc-config.json', async () => {
+		const { adapt } = await import('../src/adapt.js');
+		create_build_output(tmp_dir);
+		await adapt();
+		const vc_config = JSON.parse(
+			readFileSync(
+				join(tmp_dir, '.vercel', 'output', 'functions', 'index.func', '.vc-config.json'),
+				'utf-8',
+			),
+		);
+		expect(vc_config.handler).toBe('index.js');
+		expect(vc_config.launcherType).toBe('Nodejs');
+		expect(vc_config.experimentalResponseStreaming).toBe(true);
+		expect(vc_config.framework.slug).toBe('ripple');
+		expect(vc_config.framework.version).toMatch(/^\d+\.\d+\.\d+/);
+		expect(vc_config.runtime).toMatch(/^nodejs\d+\.x$/);
+	});
+	it('generates ESM package.json in function directory', async () => {
+		const { adapt } = await import('../src/adapt.js');
+		create_build_output(tmp_dir);
+		await adapt();
+		const pkg = JSON.parse(
+			readFileSync(
+				join(tmp_dir, '.vercel', 'output', 'functions', 'index.func', 'package.json'),
+				'utf-8',
+			),
+		);
+		expect(pkg.type).toBe('module');
+	});
+	it('generates handler that bridges Node.js req/res to Ripple fetch handler', async () => {
+		const { adapt } = await import('../src/adapt.js');
+		create_build_output(tmp_dir);
+		await adapt();
+		const handler_source = readFileSync(
+			join(tmp_dir, '.vercel', 'output', 'functions', 'index.func', 'index.js'),
+			'utf-8',
+		);
+		expect(handler_source).toContain('import { handler }');
+		expect(handler_source).toContain(
+			"import { nodeRequestToWebRequest, webResponseToNodeResponse } from '@ripple-ts/adapter-node'",
+		);
+		expect(handler_source).toContain('export default async function (req, res)');
+		expect(handler_source).toContain('nodeRequestToWebRequest(req, controller.signal, true)');
+		expect(handler_source).toContain('webResponseToNodeResponse(response, res,');
+		// Handler should import the server entry at its project-relative path
+		// (dist/server/entry.js), not just "entry.js"
+		expect(handler_source).toContain('dist/server/entry.js');
+	});
+	it('respects custom outDir', async () => {
+		const { adapt } = await import('../src/adapt.js');
+		create_build_output(tmp_dir, { outDir: 'build' });
+		await adapt({ outDir: 'build' });
+		expect(existsSync(join(tmp_dir, '.vercel', 'output', 'config.json'))).toBe(true);
+		expect(existsSync(join(tmp_dir, '.vercel', 'output', 'functions', 'index.func'))).toBe(true);
+	});
+	it('applies serverless config options', async () => {
+		const { adapt } = await import('../src/adapt.js');
+		create_build_output(tmp_dir);
+		await adapt({
+			serverless: {
+				runtime: 'nodejs22.x',
+				regions: ['iad1', 'sfo1'],
+				memory: 1024,
+				maxDuration: 30,
+			},
+		});
+		const vc_config = JSON.parse(
+			readFileSync(
+				join(tmp_dir, '.vercel', 'output', 'functions', 'index.func', '.vc-config.json'),
+				'utf-8',
+			),
+		);
+		expect(vc_config.runtime).toBe('nodejs22.x');
+		expect(vc_config.regions).toEqual(['iad1', 'sfo1']);
+		expect(vc_config.memory).toBe(1024);
+		expect(vc_config.maxDuration).toBe(30);
+	});
+	it('includes custom redirects in config', async () => {
+		const { adapt } = await import('../src/adapt.js');
+		create_build_output(tmp_dir);
+		await adapt({
+			redirects: [{ source: '/old', destination: '/new', permanent: true }],
+		});
+		const config = JSON.parse(
+			readFileSync(join(tmp_dir, '.vercel', 'output', 'config.json'), 'utf-8'),
+		);
+		const redirect = config.routes.find(
+			(/** @type {any} */ r) => r.src === '/old' && r.headers?.Location,
+		);
+		expect(redirect).toBeTruthy();
+		expect(redirect.headers.Location).toBe('/new');
+		expect(redirect.status).toBe(308);
+	});
+	it('includes custom headers in config', async () => {
+		const { adapt } = await import('../src/adapt.js');
+		create_build_output(tmp_dir);
+		await adapt({
+			headers: [
+				{
+					source: '/(.*)',
+					headers: [{ key: 'X-Custom', value: 'test' }],
+				},
+			],
+		});
+		const config = JSON.parse(
+			readFileSync(join(tmp_dir, '.vercel', 'output', 'config.json'), 'utf-8'),
+		);
+		const header_route = config.routes.find(
+			(/** @type {any} */ r) => r.src === '/(.*)' && r.headers?.['X-Custom'],
+		);
+		expect(header_route).toBeTruthy();
+		expect(header_route.headers['X-Custom']).toBe('test');
+	});
+	it('includes images config when provided', async () => {
+		const { adapt } = await import('../src/adapt.js');
+		create_build_output(tmp_dir);
+		await adapt({
+			images: {
+				sizes: [640, 1080, 1920],
+				domains: ['example.com'],
+				formats: ['image/avif', 'image/webp'],
+			},
+		});
+		const config = JSON.parse(
+			readFileSync(join(tmp_dir, '.vercel', 'output', 'config.json'), 'utf-8'),
+		);
+		expect(config.images).toEqual({
+			sizes: [640, 1080, 1920],
+			domains: ['example.com'],
+			formats: ['image/avif', 'image/webp'],
+		});
+	});
+	it('cleans previous output before generating', async () => {
+		const { adapt } = await import('../src/adapt.js');
+		create_build_output(tmp_dir);
+		// Create a stale file in the output directory
+		const stale_dir = join(tmp_dir, '.vercel', 'output', 'stale');
+		mkdirSync(stale_dir, { recursive: true });
+		writeFileSync(join(stale_dir, 'old-file.txt'), 'stale');
+		await adapt();
+		// Stale file should be gone
+		expect(existsSync(join(stale_dir, 'old-file.txt'))).toBe(false);
+		// Fresh output should exist
+		expect(existsSync(join(tmp_dir, '.vercel', 'output', 'config.json'))).toBe(true);
+	});
+	it('handles trailingSlash option', async () => {
+		const { adapt } = await import('../src/adapt.js');
+		create_build_output(tmp_dir);
+		await adapt({ trailingSlash: true });
+		const config = JSON.parse(
+			readFileSync(join(tmp_dir, '.vercel', 'output', 'config.json'), 'utf-8'),
+		);
+		expect(config.trailingSlash).toBe(true);
+	});
+	it('handles cleanUrls option', async () => {
+		const { adapt } = await import('../src/adapt.js');
+		create_build_output(tmp_dir);
+		await adapt({ cleanUrls: false });
+		const config = JSON.parse(
+			readFileSync(join(tmp_dir, '.vercel', 'output', 'config.json'), 'utf-8'),
+		);
+		expect(config.cleanUrls).toBe(false);
+	});
+	// ---------------------------------------------------------------
+	// ISR (Incremental Static Regeneration)
+	// ---------------------------------------------------------------
+	it('adds prerender config to .vc-config.json when isr is set', async () => {
+		const { adapt } = await import('../src/adapt.js');
+		create_build_output(tmp_dir);
+		await adapt({
+			isr: {
+				expiration: 60,
+			},
+		});
+		const vc_config = JSON.parse(
+			readFileSync(
+				join(tmp_dir, '.vercel', 'output', 'functions', 'index.func', '.vc-config.json'),
+				'utf-8',
+			),
+		);
+		expect(vc_config.prerender).toBeTruthy();
+		expect(vc_config.prerender.expiration).toBe(60);
+	});
+	it('supports isr.expiration = false for never-expiring cache', async () => {
+		const { adapt } = await import('../src/adapt.js');
+		create_build_output(tmp_dir);
+		await adapt({
+			isr: {
+				expiration: false,
+			},
+		});
+		const vc_config = JSON.parse(
+			readFileSync(
+				join(tmp_dir, '.vercel', 'output', 'functions', 'index.func', '.vc-config.json'),
+				'utf-8',
+			),
+		);
+		expect(vc_config.prerender).toBeTruthy();
+		expect(vc_config.prerender.expiration).toBe(false);
+	});
+	it('includes bypassToken and allowQuery in prerender config', async () => {
+		const { adapt } = await import('../src/adapt.js');
+		create_build_output(tmp_dir);
+		await adapt({
+			isr: {
+				expiration: 300,
+				bypassToken: 'my-secret-token',
+				allowQuery: ['page', 'q'],
+			},
+		});
+		const vc_config = JSON.parse(
+			readFileSync(
+				join(tmp_dir, '.vercel', 'output', 'functions', 'index.func', '.vc-config.json'),
+				'utf-8',
+			),
+		);
+		expect(vc_config.prerender.expiration).toBe(300);
+		expect(vc_config.prerender.bypassToken).toBe('my-secret-token');
+		expect(vc_config.prerender.allowQuery).toEqual(['page', 'q']);
+	});
+	it('does not add prerender config when isr is false', async () => {
+		const { adapt } = await import('../src/adapt.js');
+		create_build_output(tmp_dir);
+		await adapt({ isr: false });
+		const vc_config = JSON.parse(
+			readFileSync(
+				join(tmp_dir, '.vercel', 'output', 'functions', 'index.func', '.vc-config.json'),
+				'utf-8',
+			),
+		);
+		expect(vc_config.prerender).toBeUndefined();
+	});
+	it('does not add prerender config when isr is omitted', async () => {
+		const { adapt } = await import('../src/adapt.js');
+		create_build_output(tmp_dir);
+		await adapt();
+		const vc_config = JSON.parse(
+			readFileSync(
+				join(tmp_dir, '.vercel', 'output', 'functions', 'index.func', '.vc-config.json'),
+				'utf-8',
+			),
+		);
+		expect(vc_config.prerender).toBeUndefined();
+	});
+});

package/tests/types.test.js ADDED Viewed

@@ -0,0 +1,84 @@
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+describe('adapter-vercel types', () => {
+	it('exports runtime and serve from adapter-node', () => {
+		const types = readFileSync(join(__dirname, '..', 'types', 'index.d.ts'), 'utf-8');
+		// Re-exports runtime
+		expect(types).toContain('export const runtime: RuntimePrimitives');
+		// Re-exports serve
+		expect(types).toContain('export const serve: ServeFunction');
+	});
+	it('declares AdaptOptions interface', () => {
+		const types = readFileSync(join(__dirname, '..', 'types', 'index.d.ts'), 'utf-8');
+		expect(types).toContain('export interface AdaptOptions');
+		expect(types).toContain('outDir?: string');
+		expect(types).toContain('serverless?: ServerlessConfig');
+	});
+	it('declares ServerlessConfig interface', () => {
+		const types = readFileSync(join(__dirname, '..', 'types', 'index.d.ts'), 'utf-8');
+		expect(types).toContain('export interface ServerlessConfig');
+		expect(types).toContain('runtime?: string');
+		expect(types).toContain('regions?: string[]');
+		expect(types).toContain('maxDuration?: number');
+		expect(types).toContain('memory?: number');
+	});
+	it('declares VercelConfig interface for Build Output API v3', () => {
+		const types = readFileSync(join(__dirname, '..', 'types', 'index.d.ts'), 'utf-8');
+		expect(types).toContain('export interface VercelConfig');
+		expect(types).toContain('version: 3');
+		expect(types).toContain('routes: VercelRoute[]');
+	});
+	it('uses shared type aliases from @ripple-ts/adapter', () => {
+		const types = readFileSync(join(__dirname, '..', 'types', 'index.d.ts'), 'utf-8');
+		expect(types).toContain("from '@ripple-ts/adapter'");
+		expect(types).toContain('RuntimePrimitives');
+		expect(types).toContain('ServeFunction');
+	});
+	it('declares adapt() function', () => {
+		const types = readFileSync(join(__dirname, '..', 'types', 'index.d.ts'), 'utf-8');
+		expect(types).toContain('export function adapt(options?: AdaptOptions): Promise<void>');
+	});
+	it('declares ISRConfig interface', () => {
+		const types = readFileSync(join(__dirname, '..', 'types', 'index.d.ts'), 'utf-8');
+		expect(types).toContain('export interface ISRConfig');
+		expect(types).toContain('expiration: number | false');
+		expect(types).toContain('bypassToken?: string');
+		expect(types).toContain('allowQuery?: string[]');
+	});
+	it('declares ImagesConfig interface', () => {
+		const types = readFileSync(join(__dirname, '..', 'types', 'index.d.ts'), 'utf-8');
+		expect(types).toContain('export interface ImagesConfig');
+		expect(types).toContain('sizes: number[]');
+		expect(types).toContain('domains: string[]');
+	});
+	it('declares Vercel routing types', () => {
+		const types = readFileSync(join(__dirname, '..', 'types', 'index.d.ts'), 'utf-8');
+		expect(types).toContain('export interface VercelHeader');
+		expect(types).toContain('export interface VercelRedirect');
+		expect(types).toContain('export interface VercelRewrite');
+		expect(types).toContain('export interface VercelRoute');
+	});
+});