@sveltejs/adapter-netlify 1.0.0-next.9 → 1.0.1

package/README.md

@@ -1,18 +1,115 @@
 # adapter-netlify
 
-Adapter for Svelte apps that creates a Netlify app, using a function for dynamic server rendering. A future version might use a function per route, though it's unclear if that has any real advantages.
+A SvelteKit adapter that creates a Netlify app.
 
-This is very experimental; the adapter API isn't at all fleshed out, and things will definitely change.
+If you're using [adapter-auto](../adapter-auto), you don't need to install this unless you need to specify Netlify-specific options, since it's already included.
 
-## Configuration
+## Installation
 
-This adapter expects to find a [netlify.toml](https://docs.netlify.com/configure-builds/file-based-configuration) file in the project root. It will determine where to write static assets and functions to based on the `build.publish` and `build.functions` settings, as per this sample configuration:
+```bash
+npm i -D @sveltejs/adapter-netlify
+```
+
+You can then configure it inside of `svelte.config.js`:
+
+```js
+import adapter from '@sveltejs/adapter-netlify';
+
+export default {
+  kit: {
+    // default options are shown
+    adapter: adapter({
+      // if true, will create a Netlify Edge Function rather
+      // than using standard Node-based functions
+      edge: false,
+
+      // if true, will split your app into multiple functions
+      // instead of creating a single one for the entire app.
+      // if `edge` is true, this option cannot be used
+      split: false
+    })
+  }
+};
+```
+
+Then, make sure you have a [netlify.toml](https://docs.netlify.com/configure-builds/file-based-configuration) file in the project root. This will determine where to write static assets based on the `build.publish` settings, as per this sample configuration:
 
 ```toml
 [build]
   command = "npm run build"
-  publish = "build/"
-  functions = "functions/"
+  publish = "build"
 ```
 
-It's recommended that you add the `build` and `functions` folders (or whichever other folders you specify) to your `.gitignore`.
+If the `netlify.toml` file or the `build.publish` value is missing, a default value of `"build"` will be used. Note that if you have set the publish directory in the Netlify UI to something else then you will need to set it in `netlify.toml` too, or use the default value of `"build"`.
+
+### Node version
+
+New projects will use Node 16 by default. However, if you're upgrading a project you created a while ago it may be stuck on an older version. See [the Netlify docs](https://docs.netlify.com/configure-builds/manage-dependencies/#node-js-and-javascript) for details on manually specifying Node 16 or newer.
+
+## Netlify Edge Functions (beta)
+
+SvelteKit supports the beta release of [Netlify Edge Functions](https://docs.netlify.com/netlify-labs/experimental-features/edge-functions/). If you pass the option `edge: true` to the `adapter` function, server-side rendering will happen in a Deno-based edge function that's deployed close to the site visitor. If set to `false` (the default), the site will deploy to standard Node-based Netlify Functions.
+
+```js
+import adapter from '@sveltejs/adapter-netlify';
+
+export default {
+  kit: {
+    adapter: adapter({
+      // will create a Netlify Edge Function using Deno-based
+      // rather than using standard Node-based functions
+      edge: true
+    })
+  }
+};
+```
+
+## Netlify alternatives to SvelteKit functionality
+
+You may build your app using functionality provided directly by SvelteKit without relying on any Netlify functionality. Using the SvelteKit versions of these features will allow them to be used in dev mode, tested with integration tests, and to work with other adapters should you ever decide to switch away from Netlify. However, in some scenarios you may find it beneficial to use the Netlify versions of these features. One example would be if you're migrating an app that's already hosted on Netlify to SvelteKit.
+
+### Using Netlify Redirect Rules
+
+During compilation, redirect rules are automatically appended to your `_redirects` file. (If it doesn't exist yet, it will be created.) That means:
+
+- `[[redirects]]` in `netlify.toml` will never match as `_redirects` has a [higher priority](https://docs.netlify.com/routing/redirects/#rule-processing-order). So always put your rules in the [`_redirects` file](https://docs.netlify.com/routing/redirects/#syntax-for-the-redirects-file).
+- `_redirects` shouldn't have any custom "catch all" rules such as `/* /foobar/:splat`. Otherwise the automatically appended rule will never be applied as Netlify is only processing [the first matching rule](https://docs.netlify.com/routing/redirects/#rule-processing-order).
+
+### Using Netlify Forms
+
+1. Create your Netlify HTML form as described [here](https://docs.netlify.com/forms/setup/#html-forms), e.g. as `/routes/contact.svelte`. (Don't forget to add the hidden `form-name` input element!)
+2. Netlify's build bot parses your HTML files at deploy time, which means your form must be [prerendered](https://kit.svelte.dev/docs/page-options#prerender) as HTML. You can either add `export const prerender = true` to your `contact.svelte` to prerender just that page or set the `kit.prerender.force: true` option to prerender all pages.
+3. If your Netlify form has a [custom success message](https://docs.netlify.com/forms/setup/#success-messages) like `<form netlify ... action="/success">` then ensure the corresponding `/routes/success.svelte` exists and is prerendered.
+
+### Using Netlify Functions
+
+With this adapter, SvelteKit endpoints are hosted as [Netlify Functions](https://docs.netlify.com/functions/overview/). Netlify function handlers have additional context, including [Netlify Identity](https://docs.netlify.com/visitor-access/identity/) information. You can access this context via the `event.platform.context` field inside your hooks and `+page.server` or `+layout.server` endpoints. These are [serverless functions](https://docs.netlify.com/functions/overview/) when the `edge` property is `false` in the adapter config or [edge functions](https://docs.netlify.com/edge-functions/overview/#app) when it is `true`.
+
+```js
+// +page.server.js
+export const load = async (event) => {
+  const context = event.platform.context;
+  console.log(context); // shows up in your functions log in the Netlify app
+};
+```
+
+Additionally, you can add your own Netlify functions by creating a directory for them and adding the configuration to your `netlify.toml` file. For example:
+
+```toml
+[build]
+  command = "npm run build"
+  publish = "build"
+
+[functions]
+  directory = "functions"
+```
+
+## Troubleshooting
+
+### Accessing the file system
+
+You can't access the file system through methods like `fs.readFileSync` in Serverless/Edge environments. If you need to access files that way, do that during building the app through [prerendering](https://kit.svelte.dev/docs/page-options#prerender). If you have a blog for example and don't want to manage your content through a CMS, then you need to prerender the content (or prerender the endpoint from which you get it) and redeploy your blog everytime you add new content.
+
+## Changelog
+
+[The Changelog for this package is available on GitHub](https://github.com/sveltejs/kit/blob/master/packages/adapter-netlify/CHANGELOG.md).

package/files/edge.js

@@ -0,0 +1,59 @@
+import { Server } from '0SERVER';
+import { manifest, prerendered } from 'MANIFEST';
+
+const server = new Server(manifest);
+const prefix = `/${manifest.appPath}/`;
+
+const initialized = server.init({
+	// @ts-ignore
+	env: Deno.env.toObject()
+});
+
+/**
+ * @param { Request } request
+ * @param { any } context
+ * @returns { Promise<Response> }
+ */
+export default async function handler(request, context) {
+	if (is_static_file(request)) {
+		// Static files can skip the handler
+		// TODO can we serve _app/immutable files with an immutable cache header?
+		return;
+	}
+
+	await initialized;
+	return server.respond(request, {
+		platform: { context },
+		getClientAddress() {
+			return context.ip;
+		}
+	});
+}
+
+/**
+ * @param {Request} request
+ */
+function is_static_file(request) {
+	const url = new URL(request.url);
+
+	// Assets in the app dir
+	if (url.pathname.startsWith(prefix)) {
+		return true;
+	}
+
+	// prerendered pages and index.html files
+	const pathname = url.pathname.replace(/\/$/, '');
+	let file = pathname.substring(1);
+
+	try {
+		file = decodeURIComponent(file);
+	} catch (err) {
+		// ignore
+	}
+
+	return (
+		manifest.assets.has(file) ||
+		manifest.assets.has(file + '/index.html') ||
+		prerendered.has(pathname || '/')
+	);
+}

package/files/esm/serverless.js

@@ -0,0 +1,366 @@
+import './shims.js';
+import { Server } from '0SERVER';
+import 'assert';
+import 'net';
+import 'http';
+import 'stream';
+import 'buffer';
+import 'util';
+import 'querystring';
+import 'stream/web';
+import 'worker_threads';
+import 'perf_hooks';
+import 'util/types';
+import 'url';
+import 'events';
+import 'tls';
+import 'async_hooks';
+import 'console';
+import 'zlib';
+import 'string_decoder';
+import 'crypto';
+import 'diagnostics_channel';
+
+var setCookieExports = {};
+var setCookie = {
+  get exports(){ return setCookieExports; },
+  set exports(v){ setCookieExports = v; },
+};
+
+var defaultParseOptions = {
+  decodeValues: true,
+  map: false,
+  silent: false,
+};
+
+function isNonEmptyString(str) {
+  return typeof str === "string" && !!str.trim();
+}
+
+function parseString(setCookieValue, options) {
+  var parts = setCookieValue.split(";").filter(isNonEmptyString);
+
+  var nameValuePairStr = parts.shift();
+  var parsed = parseNameValuePair(nameValuePairStr);
+  var name = parsed.name;
+  var value = parsed.value;
+
+  options = options
+    ? Object.assign({}, defaultParseOptions, options)
+    : defaultParseOptions;
+
+  try {
+    value = options.decodeValues ? decodeURIComponent(value) : value; // decode cookie value
+  } catch (e) {
+    console.error(
+      "set-cookie-parser encountered an error while decoding a cookie with value '" +
+        value +
+        "'. Set options.decodeValues to false to disable this feature.",
+      e
+    );
+  }
+
+  var cookie = {
+    name: name,
+    value: value,
+  };
+
+  parts.forEach(function (part) {
+    var sides = part.split("=");
+    var key = sides.shift().trimLeft().toLowerCase();
+    var value = sides.join("=");
+    if (key === "expires") {
+      cookie.expires = new Date(value);
+    } else if (key === "max-age") {
+      cookie.maxAge = parseInt(value, 10);
+    } else if (key === "secure") {
+      cookie.secure = true;
+    } else if (key === "httponly") {
+      cookie.httpOnly = true;
+    } else if (key === "samesite") {
+      cookie.sameSite = value;
+    } else {
+      cookie[key] = value;
+    }
+  });
+
+  return cookie;
+}
+
+function parseNameValuePair(nameValuePairStr) {
+  // Parses name-value-pair according to rfc6265bis draft
+
+  var name = "";
+  var value = "";
+  var nameValueArr = nameValuePairStr.split("=");
+  if (nameValueArr.length > 1) {
+    name = nameValueArr.shift();
+    value = nameValueArr.join("="); // everything after the first =, joined by a "=" if there was more than one part
+  } else {
+    value = nameValuePairStr;
+  }
+
+  return { name: name, value: value };
+}
+
+function parse(input, options) {
+  options = options
+    ? Object.assign({}, defaultParseOptions, options)
+    : defaultParseOptions;
+
+  if (!input) {
+    if (!options.map) {
+      return [];
+    } else {
+      return {};
+    }
+  }
+
+  if (input.headers && input.headers["set-cookie"]) {
+    // fast-path for node.js (which automatically normalizes header names to lower-case
+    input = input.headers["set-cookie"];
+  } else if (input.headers) {
+    // slow-path for other environments - see #25
+    var sch =
+      input.headers[
+        Object.keys(input.headers).find(function (key) {
+          return key.toLowerCase() === "set-cookie";
+        })
+      ];
+    // warn if called on a request-like object with a cookie header rather than a set-cookie header - see #34, 36
+    if (!sch && input.headers.cookie && !options.silent) {
+      console.warn(
+        "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."
+      );
+    }
+    input = sch;
+  }
+  if (!Array.isArray(input)) {
+    input = [input];
+  }
+
+  options = options
+    ? Object.assign({}, defaultParseOptions, options)
+    : defaultParseOptions;
+
+  if (!options.map) {
+    return input.filter(isNonEmptyString).map(function (str) {
+      return parseString(str, options);
+    });
+  } else {
+    var cookies = {};
+    return input.filter(isNonEmptyString).reduce(function (cookies, str) {
+      var cookie = parseString(str, options);
+      cookies[cookie.name] = cookie;
+      return cookies;
+    }, cookies);
+  }
+}
+
+/*
+  Set-Cookie header field-values are sometimes comma joined in one string. This splits them without choking on commas
+  that are within a single set-cookie field-value, such as in the Expires portion.
+
+  This is uncommon, but explicitly allowed - see https://tools.ietf.org/html/rfc2616#section-4.2
+  Node.js does this for every header *except* set-cookie - see https://github.com/nodejs/node/blob/d5e363b77ebaf1caf67cd7528224b651c86815c1/lib/_http_incoming.js#L128
+  React Native's fetch does this for *every* header, including set-cookie.
+
+  Based on: https://github.com/google/j2objc/commit/16820fdbc8f76ca0c33472810ce0cb03d20efe25
+  Credits to: https://github.com/tomball for original and https://github.com/chrusart for JavaScript implementation
+*/
+function splitCookiesString(cookiesString) {
+  if (Array.isArray(cookiesString)) {
+    return cookiesString;
+  }
+  if (typeof cookiesString !== "string") {
+    return [];
+  }
+
+  var cookiesStrings = [];
+  var pos = 0;
+  var start;
+  var ch;
+  var lastComma;
+  var nextStart;
+  var cookiesSeparatorFound;
+
+  function skipWhitespace() {
+    while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
+      pos += 1;
+    }
+    return pos < cookiesString.length;
+  }
+
+  function notSpecialChar() {
+    ch = cookiesString.charAt(pos);
+
+    return ch !== "=" && ch !== ";" && ch !== ",";
+  }
+
+  while (pos < cookiesString.length) {
+    start = pos;
+    cookiesSeparatorFound = false;
+
+    while (skipWhitespace()) {
+      ch = cookiesString.charAt(pos);
+      if (ch === ",") {
+        // ',' is a cookie separator if we have later first '=', not ';' or ','
+        lastComma = pos;
+        pos += 1;
+
+        skipWhitespace();
+        nextStart = pos;
+
+        while (pos < cookiesString.length && notSpecialChar()) {
+          pos += 1;
+        }
+
+        // currently special character
+        if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+          // we found cookies separator
+          cookiesSeparatorFound = true;
+          // pos is inside the next cookie, so back up and return it.
+          pos = nextStart;
+          cookiesStrings.push(cookiesString.substring(start, lastComma));
+          start = pos;
+        } else {
+          // in param ',' or param separator ';',
+          // we continue from that comma
+          pos = lastComma + 1;
+        }
+      } else {
+        pos += 1;
+      }
+    }
+
+    if (!cookiesSeparatorFound || pos >= cookiesString.length) {
+      cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
+    }
+  }
+
+  return cookiesStrings;
+}
+
+setCookie.exports = parse;
+setCookieExports.parse = parse;
+setCookieExports.parseString = parseString;
+var splitCookiesString_1 = setCookieExports.splitCookiesString = splitCookiesString;
+
+/**
+ * Splits headers into two categories: single value and multi value
+ * @param {Headers} headers
+ * @returns {{
+ *   headers: Record<string, string>,
+ *   multiValueHeaders: Record<string, string[]>
+ * }}
+ */
+function split_headers(headers) {
+	/** @type {Record<string, string>} */
+	const h = {};
+
+	/** @type {Record<string, string[]>} */
+	const m = {};
+
+	headers.forEach((value, key) => {
+		if (key === 'set-cookie') {
+			m[key] = splitCookiesString_1(value);
+		} else {
+			h[key] = value;
+		}
+	});
+
+	return {
+		headers: h,
+		multiValueHeaders: m
+	};
+}
+
+/**
+ * @param {import('@sveltejs/kit').SSRManifest} manifest
+ * @returns {import('@netlify/functions').Handler}
+ */
+function init(manifest) {
+	const server = new Server(manifest);
+
+	let init_promise = server.init({
+		env: process.env
+	});
+
+	return async (event, context) => {
+		if (init_promise !== null) {
+			await init_promise;
+			init_promise = null;
+		}
+
+		const response = await server.respond(to_request(event), {
+			platform: { context },
+			getClientAddress() {
+				return event.headers['x-nf-client-connection-ip'];
+			}
+		});
+
+		const partial_response = {
+			statusCode: response.status,
+			...split_headers(response.headers)
+		};
+
+		if (!is_text(response.headers.get('content-type'))) {
+			// Function responses should be strings (or undefined), and responses with binary
+			// content should be base64 encoded and set isBase64Encoded to true.
+			// https://github.com/netlify/functions/blob/main/src/function/response.ts
+			return {
+				...partial_response,
+				isBase64Encoded: true,
+				body: Buffer.from(await response.arrayBuffer()).toString('base64')
+			};
+		}
+
+		return {
+			...partial_response,
+			body: await response.text()
+		};
+	};
+}
+
+/**
+ * @param {import('@netlify/functions').HandlerEvent} event
+ * @returns {Request}
+ */
+function to_request(event) {
+	const { httpMethod, headers, rawUrl, body, isBase64Encoded } = event;
+
+	/** @type {RequestInit} */
+	const init = {
+		method: httpMethod,
+		headers: new Headers(headers)
+	};
+
+	if (httpMethod !== 'GET' && httpMethod !== 'HEAD') {
+		const encoding = isBase64Encoded ? 'base64' : 'utf-8';
+		init.body = typeof body === 'string' ? Buffer.from(body, encoding) : body;
+	}
+
+	return new Request(rawUrl, init);
+}
+
+const text_types = new Set([
+	'application/xml',
+	'application/json',
+	'application/x-www-form-urlencoded',
+	'multipart/form-data'
+]);
+
+/**
+ * Decides how the body should be parsed based on its mime type
+ *
+ * @param {string | undefined | null} content_type The `content-type` header of a request/response.
+ * @returns {boolean}
+ */
+function is_text(content_type) {
+	if (!content_type) return true; // defaults to json
+	const type = content_type.split(';')[0].toLowerCase(); // get the mime type
+
+	return type.startsWith('text/') || type.endsWith('+xml') || text_types.has(type);
+}
+
+export { init };