@sveltejs/adapter-netlify 1.0.0-next.35 → 1.0.0-next.39

package/index.js

@@ -1,83 +1,164 @@
 import { appendFileSync, existsSync, readFileSync, writeFileSync } from 'fs';
 import { join, resolve } from 'path';
 import { fileURLToPath } from 'url';
+import glob from 'tiny-glob/sync.js';
 import esbuild from 'esbuild';
 import toml from '@iarna/toml';
 
 /**
- * @typedef {import('esbuild').BuildOptions} BuildOptions
+ * @typedef {{
+ *   build?: { publish?: string }
+ *   functions?: { node_bundler?: 'zisi' | 'esbuild' }
+ * } & toml.JsonMap} NetlifyConfig
  */
 
+const files = fileURLToPath(new URL('./files', import.meta.url));
+
 /** @type {import('.')} */
-export default function (options) {
+export default function ({ split = false } = {}) {
 	return {
 		name: '@sveltejs/adapter-netlify',
 
-		async adapt({ utils }) {
-			// "build" is the default publish directory when Netlify detects SvelteKit
-			const publish = get_publish_directory(utils) || 'build';
-
-			utils.log.minor(`Publishing to "${publish}"`);
-
-			utils.rimraf(publish);
+		async adapt(builder) {
+			const netlify_config = get_netlify_config();
 
-			const files = fileURLToPath(new URL('./files', import.meta.url));
-
-			utils.log.minor('Generating serverless function...');
-			utils.copy(join(files, 'entry.js'), '.svelte-kit/netlify/entry.js');
-
-			/** @type {BuildOptions} */
-			const default_options = {
-				entryPoints: ['.svelte-kit/netlify/entry.js'],
-				// Any functions in ".netlify/functions-internal" are bundled in addition to user-defined Netlify functions.
-				// See https://github.com/netlify/build/pull/3213 for more details
-				outfile: '.netlify/functions-internal/__render.js',
-				bundle: true,
-				inject: [join(files, 'shims.js')],
-				platform: 'node'
-			};
+			// "build" is the default publish directory when Netlify detects SvelteKit
+			const publish = get_publish_directory(netlify_config, builder) || 'build';
 
-			const build_options =
-				options && options.esbuild ? await options.esbuild(default_options) : default_options;
+			// empty out existing build directories
+			builder.rimraf(publish);
+			builder.rimraf('.netlify/functions-internal');
+			builder.rimraf('.netlify/server');
+			builder.rimraf('.netlify/package.json');
+			builder.rimraf('.netlify/handler.js');
 
-			await esbuild.build(build_options);
+			builder.mkdirp('.netlify/functions-internal');
 
-			writeFileSync(join('.netlify', 'package.json'), JSON.stringify({ type: 'commonjs' }));
+			builder.log.minor(`Publishing to "${publish}"`);
 
-			utils.log.minor('Prerendering static pages...');
-			await utils.prerender({
+			builder.log.minor('Prerendering static pages...');
+			await builder.prerender({
 				dest: publish
 			});
 
-			utils.log.minor('Copying assets...');
-			utils.copy_static_files(publish);
-			utils.copy_client_files(publish);
-
-			utils.log.minor('Writing redirects...');
-
-			const redirectPath = join(publish, '_redirects');
-			utils.copy('_redirects', redirectPath);
-			appendFileSync(redirectPath, '\n\n/* /.netlify/functions/__render 200');
+			builder.writeServer('.netlify/server');
+
+			// for esbuild, use ESM
+			// for zip-it-and-ship-it, use CJS until https://github.com/netlify/zip-it-and-ship-it/issues/750
+			const esm = netlify_config?.functions?.node_bundler === 'esbuild';
+
+			/** @type {string[]} */
+			const redirects = [];
+
+			if (esm) {
+				builder.copy(`${files}/esm`, '.netlify');
+			} else {
+				glob('**/*.js', { cwd: '.netlify/server' }).forEach((file) => {
+					const filepath = `.netlify/server/${file}`;
+					const input = readFileSync(filepath, 'utf8');
+					const output = esbuild.transformSync(input, { format: 'cjs', target: 'node12' }).code;
+					writeFileSync(filepath, output);
+				});
+
+				builder.copy(`${files}/cjs`, '.netlify');
+				writeFileSync(join('.netlify', 'package.json'), JSON.stringify({ type: 'commonjs' }));
+			}
+
+			if (split) {
+				builder.log.minor('Generating serverless functions...');
+
+				builder.createEntries((route) => {
+					const parts = [];
+
+					for (const segment of route.segments) {
+						if (segment.rest) {
+							parts.push('*');
+							break; // Netlify redirects don't allow anything after a *
+						} else if (segment.dynamic) {
+							parts.push(`:${parts.length}`);
+						} else {
+							parts.push(segment.content);
+						}
+					}
+
+					const pattern = `/${parts.join('/')}`;
+					const name = parts.join('-').replace(/[:.]/g, '_').replace('*', '__rest') || 'index';
+
+					return {
+						id: pattern,
+						filter: (other) => matches(route.segments, other.segments),
+						complete: (entry) => {
+							const manifest = entry.generateManifest({
+								relativePath: '../server',
+								format: esm ? 'esm' : 'cjs'
+							});
+
+							const fn = esm
+								? `import { init } from '../handler.js';\n\nexport const handler = init(${manifest});\n`
+								: `const { init } = require('../handler.js');\n\nexports.handler = init(${manifest});\n`;
+
+							writeFileSync(`.netlify/functions-internal/${name}.js`, fn);
+
+							redirects.push(`${pattern} /.netlify/functions/${name} 200`);
+						}
+					};
+				});
+			} else {
+				builder.log.minor('Generating serverless functions...');
+
+				const manifest = builder.generateManifest({
+					relativePath: '../server',
+					format: esm ? 'esm' : 'cjs'
+				});
+
+				const fn = esm
+					? `import { init } from '../handler.js';\n\nexport const handler = init(${manifest});\n`
+					: `const { init } = require('../handler.js');\n\nexports.handler = init(${manifest});\n`;
+
+				writeFileSync('.netlify/functions-internal/render.js', fn);
+
+				redirects.push('* /.netlify/functions/render 200');
+			}
+
+			builder.log.minor('Copying assets...');
+			builder.writeStatic(publish);
+			builder.writeClient(publish);
+
+			builder.log.minor('Writing redirects...');
+			const redirect_file = join(publish, '_redirects');
+			builder.copy('_redirects', redirect_file);
+			appendFileSync(redirect_file, `\n\n${redirects.join('\n')}`);
+
+			builder.log.minor('Writing custom headers...');
+			const headers_file = join(publish, '_headers');
+			builder.copy('_headers', headers_file);
+			appendFileSync(
+				headers_file,
+				`\n\n/${builder.appDir}/*\n  cache-control: public\n  cache-control: immutable\n  cache-control: max-age=31536000\n`
+			);
 		}
 	};
 }
+
+function get_netlify_config() {
+	if (!existsSync('netlify.toml')) return null;
+
+	try {
+		return /** @type {NetlifyConfig} */ (toml.parse(readFileSync('netlify.toml', 'utf-8')));
+	} catch (err) {
+		err.message = `Error parsing netlify.toml: ${err.message}`;
+		throw err;
+	}
+}
+
 /**
- * @param {import('@sveltejs/kit').AdapterUtils} utils
+ * @param {NetlifyConfig} netlify_config
+ * @param {import('@sveltejs/kit').Builder} builder
  **/
-function get_publish_directory(utils) {
-	if (existsSync('netlify.toml')) {
-		/** @type {{ build?: { publish?: string }} & toml.JsonMap } */
-		let netlify_config;
-
-		try {
-			netlify_config = toml.parse(readFileSync('netlify.toml', 'utf-8'));
-		} catch (err) {
-			err.message = `Error parsing netlify.toml: ${err.message}`;
-			throw err;
-		}
-
+function get_publish_directory(netlify_config, builder) {
+	if (netlify_config) {
 		if (!netlify_config.build || !netlify_config.build.publish) {
-			utils.log.warn('No publish directory specified in netlify.toml, using default');
+			builder.log.warn('No publish directory specified in netlify.toml, using default');
 			return;
 		}
 
@@ -94,7 +175,43 @@ function get_publish_directory(utils) {
 		return netlify_config.build.publish;
 	}
 
-	utils.log.warn(
+	builder.log.warn(
 		'No netlify.toml found. Using default publish directory. Consult https://github.com/sveltejs/kit/tree/master/packages/adapter-netlify#configuration for more details '
 	);
 }
+
+/**
+ * @typedef {{ rest: boolean, dynamic: boolean, content: string }} RouteSegment
+ */
+
+/**
+ * @param {RouteSegment[]} a
+ * @param {RouteSegment[]} b
+ * @returns {boolean}
+ */
+function matches(a, b) {
+	if (a[0] && b[0]) {
+		if (b[0].rest) {
+			if (b.length === 1) return true;
+
+			const next_b = b.slice(1);
+
+			for (let i = 0; i < a.length; i += 1) {
+				if (matches(a.slice(i), next_b)) return true;
+			}
+
+			return false;
+		}
+
+		if (!b[0].dynamic) {
+			if (!a[0].dynamic && a[0].content !== b[0].content) return false;
+		}
+
+		if (a.length === 1 && b.length === 1) return true;
+		return matches(a.slice(1), b.slice(1));
+	} else if (a[0]) {
+		return a.length === 1 && a[0].rest;
+	} else {
+		return b.length === 1 && b[0].rest;
+	}
+}

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@sveltejs/adapter-netlify",
-  "version": "1.0.0-next.35",
+  "version": "1.0.0-next.39",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",
     "directory": "packages/adapter-netlify"
   },
+  "license": "MIT",
   "homepage": "https://kit.svelte.dev",
   "type": "module",
   "exports": {
@@ -22,12 +23,21 @@
   ],
   "dependencies": {
     "@iarna/toml": "^2.2.5",
-    "esbuild": "^0.13.4"
+    "esbuild": "^0.13.15",
+    "tiny-glob": "^0.2.9"
   },
   "devDependencies": {
-    "@sveltejs/kit": "1.0.0-next.190"
+    "@netlify/functions": "^0.10.0",
+    "@rollup/plugin-commonjs": "^21.0.0",
+    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-node-resolve": "^13.0.5",
+    "@sveltejs/kit": "1.0.0-next.232",
+    "rimraf": "^3.0.2",
+    "rollup": "^2.58.0"
   },
   "scripts": {
+    "dev": "rimraf files && rollup -cw",
+    "build": "rimraf files && rollup -c",
     "lint": "eslint --ignore-path .gitignore \"**/*.{ts,js,svelte}\" && npm run check-format",
     "format": "npm run check-format -- --write",
     "check-format": "prettier --check . --config ../../.prettierrc --ignore-path .gitignore"

package/files/entry.js

@@ -1,71 +0,0 @@
-// TODO hardcoding the relative location makes this brittle
-import { init, render } from '../output/server/app.js';
-
-init();
-
-export async function handler(event) {
-	const { path, httpMethod, headers, rawQuery, body, isBase64Encoded } = event;
-
-	const query = new URLSearchParams(rawQuery);
-
-	const encoding = isBase64Encoded ? 'base64' : headers['content-encoding'] || 'utf-8';
-	const rawBody = typeof body === 'string' ? Buffer.from(body, encoding) : body;
-
-	const rendered = await render({
-		method: httpMethod,
-		headers,
-		path,
-		query,
-		rawBody
-	});
-
-	if (!rendered) {
-		return {
-			statusCode: 404,
-			body: 'Not found'
-		};
-	}
-
-	const partial_response = {
-		statusCode: rendered.status,
-		...split_headers(rendered.headers)
-	};
-
-	if (rendered.body instanceof Uint8Array) {
-		// Function responses should always be strings, and responses with binary
-		// content should be base64 encoded and set isBase64Encoded to true.
-		// https://github.com/netlify/functions/blob/main/src/function/response.d.ts
-		return {
-			...partial_response,
-			isBase64Encoded: true,
-			body: Buffer.from(rendered.body).toString('base64')
-		};
-	}
-
-	return {
-		...partial_response,
-		body: rendered.body
-	};
-}
-
-/**
- * Splits headers into two categories: single value and multi value
- * @param {Record<string, string | string[]>} headers
- * @returns {{
- * headers: Record<string, string>,
- * multiValueHeaders: Record<string, string[]>
- * }}
- */
-function split_headers(headers) {
-	const h = {};
-	const m = {};
-	for (const key in headers) {
-		const value = headers[key];
-		const target = Array.isArray(value) ? m : h;
-		target[key] = value;
-	}
-	return {
-		headers: h,
-		multiValueHeaders: m
-	};
-}

package/files/shims.js

@@ -1 +0,0 @@
-export { fetch, Response, Request, Headers } from '@sveltejs/kit/install-fetch';