@netlify/redirect-parser 14.4.0

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2021 Netlify <team@netlify.com>
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,6 @@
+# Netlify Redirect Parser
+
+Parses redirect rules from both `_redirects` and `netlify.toml` and normalizes them to an array of objects.
+
+For most users, you are not meant to use this directly, please refer to https://github.com/netlify/cli instead. However
+if you are debugging issues with redirect parsing, issues and PRs are welcome.

package/lib/all.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Parse all redirects given programmatically via the `configRedirects` property, `netlify.toml` and `_redirects`
+ * files, then normalize and validate those.
+ */
+export declare const parseAllRedirects: ({ redirectsFiles, netlifyConfigPath, configRedirects, minimal, }: {
+    redirectsFiles: string[];
+    netlifyConfigPath?: string;
+    configRedirects: string[];
+    minimal: boolean;
+}) => Promise<{
+    redirects: unknown[];
+    errors: any[];
+}>;

package/lib/all.js

@@ -0,0 +1,38 @@
+import { parseFileRedirects } from './line_parser.js';
+import { mergeRedirects } from './merge.js';
+import { parseConfigRedirects } from './netlify_config_parser.js';
+import { normalizeRedirects } from './normalize.js';
+import { splitResults, concatResults } from './results.js';
+/**
+ * Parse all redirects given programmatically via the `configRedirects` property, `netlify.toml` and `_redirects`
+ * files, then normalize and validate those.
+ */
+export const parseAllRedirects = async function ({ redirectsFiles = [], netlifyConfigPath, configRedirects = [], minimal = false, }) {
+    const [{ redirects: fileRedirects, errors: fileParseErrors }, { redirects: parsedConfigRedirects, errors: configParseErrors },] = await Promise.all([getFileRedirects(redirectsFiles), getConfigRedirects(netlifyConfigPath)]);
+    const { redirects: normalizedFileRedirects, errors: fileNormalizeErrors } = normalizeRedirects(fileRedirects, minimal);
+    const { redirects: normalizedParsedConfigRedirects, errors: parsedConfigNormalizeErrors } = normalizeRedirects(parsedConfigRedirects, minimal);
+    const { redirects: normalizedConfigRedirects, errors: configNormalizeErrors } = normalizeRedirects(configRedirects, minimal);
+    const { redirects, errors: mergeErrors } = mergeRedirects({
+        fileRedirects: normalizedFileRedirects,
+        configRedirects: [...normalizedParsedConfigRedirects, ...normalizedConfigRedirects],
+    });
+    const errors = [
+        ...fileParseErrors,
+        ...fileNormalizeErrors,
+        ...configParseErrors,
+        ...parsedConfigNormalizeErrors,
+        ...configNormalizeErrors,
+        ...mergeErrors,
+    ];
+    return { redirects, errors };
+};
+const getFileRedirects = async function (redirectsFiles) {
+    const resultsArrays = await Promise.all(redirectsFiles.map((redirectFile) => parseFileRedirects(redirectFile)));
+    return concatResults(resultsArrays);
+};
+const getConfigRedirects = async function (netlifyConfigPath) {
+    if (netlifyConfigPath === undefined) {
+        return splitResults([]);
+    }
+    return await parseConfigRedirects(netlifyConfigPath);
+};

package/lib/conditions.d.ts

@@ -0,0 +1 @@
+export function normalizeConditions(rawConditions: any): any;

package/lib/conditions.js

@@ -0,0 +1,31 @@
+// Normalize conditions
+export const normalizeConditions = function (rawConditions) {
+    const caseNormalizedConditions = normalizeConditionCases(rawConditions);
+    const listNormalizedConditions = normalizeConditionLists(caseNormalizedConditions);
+    return listNormalizedConditions;
+};
+// Conditions can optionally be capitalized
+const normalizeConditionCases = function (conditions) {
+    return CONDITION_CAPITALIZED_PROPS.reduce(normalizeConditionCase, conditions);
+};
+const CONDITION_CAPITALIZED_PROPS = [
+    { name: 'role', capitalizedName: 'Role' },
+    { name: 'language', capitalizedName: 'Language' },
+    { name: 'country', capitalizedName: 'Country' },
+];
+const normalizeConditionCase = function (conditions, { name, capitalizedName }) {
+    const { [capitalizedName]: capitalizedProp, [name]: prop = capitalizedProp, ...conditionsA } = conditions;
+    return prop === undefined ? conditionsA : { ...conditionsA, [capitalizedName]: prop };
+};
+// Some `conditions` are array of strings.
+// In `_redirects`, they are comma-separated lists instead.
+const normalizeConditionLists = function (conditions) {
+    return CONDITION_LIST_PROPS.reduce(normalizeConditionList, conditions);
+};
+const CONDITION_LIST_PROPS = ['Role', 'Language', 'Country'];
+const normalizeConditionList = function (conditions, name) {
+    return typeof conditions[name] === 'string'
+        ? { ...conditions, [name]: conditions[name].trim().split(CONDITION_LIST_REGEXP) }
+        : conditions;
+};
+const CONDITION_LIST_REGEXP = /\s*,\s*/gu;

package/lib/index.d.ts

@@ -0,0 +1 @@
+export { parseAllRedirects } from './all.js';

package/lib/index.js

@@ -0,0 +1 @@
+export { parseAllRedirects } from './all.js';

package/lib/line_parser.d.ts

@@ -0,0 +1,4 @@
+export function parseFileRedirects(redirectFile: any): Promise<{
+    redirects: any;
+    errors: any;
+}>;

package/lib/line_parser.js

@@ -0,0 +1,127 @@
+import { promises as fs } from 'fs';
+import { pathExists } from 'path-exists';
+import { splitResults } from './results.js';
+import { transtypeStatusCode, isValidStatusCode } from './status.js';
+import { isUrl } from './url.js';
+// Parse `_redirects` file to an array of objects.
+// Each line in that file must be either:
+//  - An empty line
+//  - A comment starting with #
+//  - A redirect line, optionally ended with a comment
+// Each redirect line has the following format:
+//   from [query] [to] [status[!]] [conditions]
+// The parts are:
+//  - "from": a path or a URL
+//  - "query": a whitespace-separated list of "key=value"
+//  - "to": a path or a URL
+//  - "status": an HTTP status integer
+//  - "!": an optional exclamation mark appended to "status" meant to indicate
+//    "forced"
+//  - "conditions": a whitespace-separated list of "key=value"
+//     - "Sign" is a special condition
+// Unlike "redirects" in "netlify.toml", the "headers" and "edge_handlers"
+// cannot be specified.
+export const parseFileRedirects = async function (redirectFile) {
+    const results = await parseRedirects(redirectFile);
+    return splitResults(results);
+};
+const parseRedirects = async function (redirectFile) {
+    if (!(await pathExists(redirectFile))) {
+        return [];
+    }
+    const text = await readRedirectFile(redirectFile);
+    if (typeof text !== 'string') {
+        return [text];
+    }
+    return text
+        .split('\n')
+        .map(normalizeLine)
+        .filter(hasRedirect)
+        .map((redirectLine) => parseRedirect(redirectLine));
+};
+const readRedirectFile = async function (redirectFile) {
+    try {
+        return await fs.readFile(redirectFile, 'utf8');
+    }
+    catch {
+        return new Error(`Could not read redirects file: ${redirectFile}`);
+    }
+};
+const normalizeLine = function (line, index) {
+    return { line: line.trim(), index };
+};
+const hasRedirect = function ({ line }) {
+    return line !== '' && !isComment(line);
+};
+const parseRedirect = function ({ line, index }) {
+    try {
+        return parseRedirectLine(line);
+    }
+    catch (error) {
+        return new Error(`Could not parse redirect line ${index + 1}:
+  ${line}
+${error.message}`);
+    }
+};
+// Parse a single redirect line
+const parseRedirectLine = function (line) {
+    const [from, ...parts] = trimComment(line.split(LINE_TOKENS_REGEXP));
+    if (parts.length === 0) {
+        throw new Error('Missing destination path/URL');
+    }
+    const { queryParts, to, lastParts: [statusPart, ...conditionsParts], } = parseParts(from, parts);
+    const query = parsePairs(queryParts);
+    const { status, force } = parseStatus(statusPart);
+    const { Sign, signed = Sign, ...conditions } = parsePairs(conditionsParts);
+    return { from, query, to, status, force, conditions, signed };
+};
+// Removes inline comments at the end of the line
+const trimComment = function (parts) {
+    const commentIndex = parts.findIndex(isComment);
+    return commentIndex === -1 ? parts : parts.slice(0, commentIndex);
+};
+const isComment = function (part) {
+    return part.startsWith('#');
+};
+const LINE_TOKENS_REGEXP = /\s+/g;
+// Figure out the purpose of each whitelist-separated part, taking into account
+// the fact that some are optional.
+const parseParts = function (from, parts) {
+    // Optional `to` field when using a forward rule.
+    // The `to` field is added and validated later on, so we can leave it
+    // `undefined`
+    if (isValidStatusCode(transtypeStatusCode(parts[0]))) {
+        return { queryParts: [], to: undefined, lastParts: parts };
+    }
+    const toIndex = parts.findIndex(isToPart);
+    if (toIndex === -1) {
+        throw new Error('The destination path/URL must start with "/", "http:" or "https:"');
+    }
+    const queryParts = parts.slice(0, toIndex);
+    const to = parts[toIndex];
+    const lastParts = parts.slice(toIndex + 1);
+    return { queryParts, to, lastParts };
+};
+const isToPart = function (part) {
+    return part.startsWith('/') || isUrl(part);
+};
+// Parse the `status` part
+const parseStatus = function (statusPart) {
+    if (statusPart === undefined) {
+        return {};
+    }
+    const status = transtypeStatusCode(statusPart);
+    if (!isValidStatusCode(status)) {
+        return { status: statusPart, force: false };
+    }
+    const force = statusPart.endsWith('!');
+    return { status, force };
+};
+// Part key=value pairs used for both the `query` and `conditions` parts
+const parsePairs = function (conditions) {
+    return Object.assign({}, ...conditions.map(parsePair));
+};
+const parsePair = function (condition) {
+    const [key, value] = condition.split('=');
+    return { [key]: value };
+};

package/lib/merge.d.ts

@@ -0,0 +1,7 @@
+export declare const mergeRedirects: ({ fileRedirects, configRedirects }: {
+    fileRedirects: any;
+    configRedirects: any;
+}) => {
+    redirects: unknown[];
+    errors: any;
+};

package/lib/merge.js

@@ -0,0 +1,31 @@
+import stringify from 'fast-safe-stringify';
+import { splitResults } from './results.js';
+// Merge redirects from `_redirects` with the ones from `netlify.toml`.
+// When both are specified, both are used and `_redirects` has priority.
+// Since in both `netlify.toml` and `_redirects`, only the first matching rule
+// is used, it is possible to merge `_redirects` to `netlify.toml` by prepending
+// its rules to `netlify.toml` `redirects` field.
+export const mergeRedirects = function ({ fileRedirects, configRedirects }) {
+    const results = [...fileRedirects, ...configRedirects];
+    const { redirects, errors } = splitResults(results);
+    const mergedRedirects = removeDuplicates(redirects);
+    return { redirects: mergedRedirects, errors };
+};
+// Remove duplicates. This is especially likely considering `fileRedirects`
+// might have been previously merged to `configRedirects`, which happens when
+// `netlifyConfig.redirects` is modified by plugins.
+// The latest duplicate value is the one kept, hence why we need to iterate the
+// array backwards and reverse it at the end
+const removeDuplicates = function (redirects) {
+    const uniqueRedirects = new Set();
+    const result = [];
+    for (let i = redirects.length - 1; i >= 0; i--) {
+        const r = redirects[i];
+        const key = stringify.default.stableStringify(r);
+        if (uniqueRedirects.has(key))
+            continue;
+        uniqueRedirects.add(key);
+        result.push(r);
+    }
+    return result.reverse();
+};

package/lib/netlify_config_parser.d.ts

@@ -0,0 +1,4 @@
+export function parseConfigRedirects(netlifyConfigPath: any): Promise<{
+    redirects: any;
+    errors: any;
+}>;

package/lib/netlify_config_parser.js

@@ -0,0 +1,30 @@
+import { promises as fs } from 'fs';
+import { parse as loadToml } from '@iarna/toml';
+import { pathExists } from 'path-exists';
+import { splitResults } from './results.js';
+// Parse `redirects` field in "netlify.toml" to an array of objects.
+// This field is already an array of objects, so it only validates and
+// normalizes it.
+export const parseConfigRedirects = async function (netlifyConfigPath) {
+    if (!(await pathExists(netlifyConfigPath))) {
+        return splitResults([]);
+    }
+    const results = await parseConfig(netlifyConfigPath);
+    return splitResults(results);
+};
+// Load the configuration file and parse it (TOML)
+const parseConfig = async function (configPath) {
+    try {
+        const configString = await fs.readFile(configPath, 'utf8');
+        const config = loadToml(configString);
+        // Convert `null` prototype objects to normal plain objects
+        const { redirects = [] } = JSON.parse(JSON.stringify(config));
+        if (!Array.isArray(redirects)) {
+            throw new TypeError(`"redirects" must be an array`);
+        }
+        return redirects;
+    }
+    catch (error) {
+        return [new Error(`Could not parse configuration file: ${error}`)];
+    }
+};

package/lib/normalize.d.ts

@@ -0,0 +1,4 @@
+export function normalizeRedirects(redirects: any, minimal: any): {
+    redirects: any;
+    errors: any;
+};

package/lib/normalize.js

@@ -0,0 +1,115 @@
+import { includeKeys } from 'filter-obj';
+import isPlainObj from 'is-plain-obj';
+import { normalizeConditions } from './conditions.js';
+import { splitResults } from './results.js';
+import { normalizeStatus } from './status.js';
+import { isUrl } from './url.js';
+// Validate and normalize an array of `redirects` objects.
+// This step is performed after `redirects` have been parsed from either
+// `netlify.toml` or `_redirects`.
+export const normalizeRedirects = function (redirects, minimal) {
+    if (!Array.isArray(redirects)) {
+        const error = new TypeError(`Redirects must be an array not: ${redirects}`);
+        return splitResults([error]);
+    }
+    const results = redirects.map((obj, index) => parseRedirect(obj, index, minimal));
+    return splitResults(results);
+};
+const parseRedirect = function (obj, index, minimal) {
+    if (!isPlainObj(obj)) {
+        return new TypeError(`Redirects must be objects not: ${obj}`);
+    }
+    try {
+        return parseRedirectObject(obj, minimal);
+    }
+    catch (error) {
+        return new Error(`Could not parse redirect number ${index + 1}:
+  ${JSON.stringify(obj)}
+${error.message}`);
+    }
+};
+// Parse a single `redirects` object
+const parseRedirectObject = function ({ 
+// `from` used to be named `origin`
+origin, from = origin, 
+// `query` used to be named `params` and `parameters`
+parameters = {}, params = parameters, query = params, 
+// `to` used to be named `destination`
+destination, to = destination, status, force = false, conditions = {}, 
+// `signed` used to be named `signing` and `sign`
+sign, signing = sign, signed = signing, headers = {}, rate_limit, }, minimal) {
+    if (from === undefined) {
+        throw new Error('Missing "from" field');
+    }
+    if (!isPlainObj(headers)) {
+        throw new Error('"headers" field must be an object');
+    }
+    const statusA = normalizeStatus(status);
+    const finalTo = addForwardRule(from, statusA, to);
+    const { scheme, host, path } = parseFrom(from);
+    const proxy = isProxy(statusA, finalTo);
+    const normalizedConditions = normalizeConditions(conditions);
+    // We ensure the return value has the same shape as our `netlify-commons`
+    // backend
+    return removeUndefinedValues({
+        from,
+        query,
+        to: finalTo,
+        status: statusA,
+        force,
+        conditions: normalizedConditions,
+        signed,
+        headers,
+        rate_limit,
+        // If `minimal: true`, does not add additional properties that are not
+        // valid in `netlify.toml`
+        ...(!minimal && { scheme, host, path, proxy }),
+    });
+};
+// Add the optional `to` field when using a forward rule
+const addForwardRule = function (from, status, to) {
+    if (to !== undefined) {
+        return to;
+    }
+    if (!isSplatRule(from, status)) {
+        throw new Error('Missing "to" field');
+    }
+    return from.replace(SPLAT_REGEXP, '/:splat');
+};
+// "to" can only be omitted when using forward rules:
+//  - This requires "from" to end with "/*" and "status" to be 2**
+//  - "to" will then default to "from" but with "/*" replaced to "/:splat"
+const isSplatRule = function (from, status) {
+    return from.endsWith('/*') && status >= 200 && status < 300;
+};
+const SPLAT_REGEXP = /\/\*$/;
+// Parses the `from` field which can be either a file path or a URL.
+const parseFrom = function (from) {
+    const { scheme, host, path } = parseFromField(from);
+    if (path.startsWith('/.netlify')) {
+        throw new Error('"path" field must not start with "/.netlify"');
+    }
+    return { scheme, host, path };
+};
+const parseFromField = function (from) {
+    if (!isUrl(from)) {
+        return { path: from };
+    }
+    try {
+        const { host, protocol, pathname: path } = new URL(from);
+        const scheme = protocol.slice(0, -1);
+        return { scheme, host, path };
+    }
+    catch (error) {
+        throw new Error(`Invalid URL: ${error.message}`);
+    }
+};
+const isProxy = function (status, to) {
+    return status === 200 && isUrl(to);
+};
+const removeUndefinedValues = function (object) {
+    return includeKeys(object, isDefined);
+};
+const isDefined = function (key, value) {
+    return value !== undefined;
+};

package/lib/results.d.ts

@@ -0,0 +1,8 @@
+export function splitResults(results: any): {
+    redirects: any;
+    errors: any;
+};
+export function concatResults(resultsArrays: any): {
+    redirects: any;
+    errors: any;
+};

package/lib/results.js

@@ -0,0 +1,21 @@
+// If one redirect fails to parse, we still try to return the other ones
+export const splitResults = function (results) {
+    const redirects = results.filter((result) => !isError(result));
+    const errors = results.filter(isError);
+    return { redirects, errors };
+};
+const isError = function (result) {
+    return result instanceof Error;
+};
+// Concatenate an array of `{ redirects, errors }`
+export const concatResults = function (resultsArrays) {
+    const redirects = resultsArrays.flatMap(getRedirects);
+    const errors = resultsArrays.flatMap(getErrors);
+    return { redirects, errors };
+};
+const getRedirects = function ({ redirects }) {
+    return redirects;
+};
+const getErrors = function ({ errors }) {
+    return errors;
+};

package/lib/status.d.ts

@@ -0,0 +1,3 @@
+export function normalizeStatus(status: any): number | undefined;
+export function transtypeStatusCode(status: any): number;
+export function isValidStatusCode(status: any): boolean;

package/lib/status.js

@@ -0,0 +1,21 @@
+// Normalize `status` field
+export const normalizeStatus = function (status) {
+    if (status === undefined) {
+        return;
+    }
+    const statusCode = transtypeStatusCode(status);
+    if (!isValidStatusCode(statusCode)) {
+        throw new Error(`Invalid status code: ${status}`);
+    }
+    return statusCode;
+};
+// Transtype `status` string to a number.
+// `status` might be a string ending with `!`. If so, `Number.parseInt()` strips
+// and ignores it.
+export const transtypeStatusCode = function (status) {
+    return Number.parseInt(status);
+};
+// Check whether the field is a valid status code
+export const isValidStatusCode = function (status) {
+    return Number.isInteger(status);
+};

package/lib/url.d.ts

@@ -0,0 +1 @@
+export function isUrl(pathOrUrl: any): boolean;

package/lib/url.js

@@ -0,0 +1,5 @@
+// Check if a field is valid redirect URL
+export const isUrl = function (pathOrUrl) {
+    return SCHEMES.some((scheme) => pathOrUrl.startsWith(scheme));
+};
+const SCHEMES = ['http://', 'https://'];

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@netlify/redirect-parser",
+  "version": "14.4.0",
+  "description": "Parses netlify redirects into a js object representation",
+  "type": "module",
+  "exports": "./lib/index.js",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "files": [
+    "lib/**/*"
+  ],
+  "scripts": {
+    "prebuild": "rm -rf lib",
+    "build": "tsc",
+    "test": "vitest run",
+    "test:bench": "vitest bench",
+    "test:dev": "vitest",
+    "test:ci": "vitest run --reporter=default && vitest bench --run --passWithNoTests"
+  },
+  "keywords": [
+    "netlify"
+  ],
+  "engines": {
+    "node": "^14.16.0 || >=16.0.0"
+  },
+  "author": "Netlify",
+  "license": "MIT",
+  "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "fast-safe-stringify": "^2.1.1",
+    "filter-obj": "^5.0.0",
+    "is-plain-obj": "^4.0.0",
+    "path-exists": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^14.18.53",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.0",
+    "vitest": "^0.34.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/netlify/build.git",
+    "directory": "packages/redirect-parser"
+  },
+  "bugs": {
+    "url": "https://github.com/netlify/build/issues"
+  },
+  "homepage": "https://github.com/netlify/build#readme",
+  "gitHead": "131a644bfde5205f730f3369b778d8914c7c0382"
+}