@netlify/config 19.0.0-rc → 19.0.0

package/lib/validate/context.js

@@ -0,0 +1,38 @@
+import { warnContextPluginConfig, throwContextPluginsConfig } from '../log/messages.js';
+import { UI_ORIGIN } from '../origin.js';
+// The only reason to specify both `[[plugins]]` and
+// `[[contexts.{context}.plugins]]` is to configure context-specific plugin
+// inputs.
+// The second cannot be used to enable a plugin for a specific context, because
+// it would be overridden by `[[plugins]]`.
+// We prevent against that mistake by printing a warning message when both are
+// used. We only do this when `[[plugins]]` is due to plugin being UI-installed.
+// We also fail the build when the following additional conditions apply:
+//  - `package` is the only property in `[[contexts.{context}.plugins]]`, i.e.
+//    there are no context-specific `inputs`
+//  - The current build is not in `context`
+export const validateContextsPluginsConfig = function ({ contextProps, plugins, contexts, logs }) {
+    Object.entries(contextProps).forEach(([givenContext, givenContextProps]) => {
+        validateContextPluginsConfig({ givenContextProps, plugins, givenContext, contexts, logs });
+    });
+};
+const validateContextPluginsConfig = function ({ givenContextProps: { plugins: contextPlugins = [] }, plugins, givenContext, contexts, logs, }) {
+    contextPlugins.forEach((pluginConfig) => {
+        validateContextPluginConfig({ pluginConfig, plugins, givenContext, contexts, logs });
+    });
+};
+const validateContextPluginConfig = function ({ pluginConfig: { package: packageName, inputs = {} }, plugins = [], givenContext, contexts, logs, }) {
+    if (!isContextFreePlugin(plugins, packageName)) {
+        return;
+    }
+    if (isPluginConfigError(contexts, givenContext, inputs)) {
+        throwContextPluginsConfig(packageName, givenContext);
+    }
+    warnContextPluginConfig(logs, packageName, givenContext);
+};
+const isContextFreePlugin = function (plugins, packageName) {
+    return plugins.some((plugin) => plugin.package === packageName && plugin.origin === UI_ORIGIN);
+};
+const isPluginConfigError = function (contexts, givenContext, inputs) {
+    return contexts.every((context) => context !== givenContext) && Object.keys(inputs).length === 0;
+};

package/lib/validate/example.js

@@ -0,0 +1,30 @@
+import indentString from 'indent-string';
+import { THEME } from '../log/theme.js';
+import { serializeToml } from '../utils/toml.js';
+// Print invalid value and example netlify.toml
+export const getExample = function ({ value, key, prevPath, example, formatInvalid }) {
+    const exampleA = typeof example === 'function' ? example(value, key, prevPath) : example;
+    return `
+${THEME.errorSubHeader('Invalid syntax')}
+
+${indentString(getInvalidValue(value, prevPath, formatInvalid), 2)}
+
+${THEME.subHeader('Valid syntax')}
+
+${indentString(serializeToml(exampleA), 2)}`;
+};
+const getInvalidValue = function (value, prevPath, formatInvalid) {
+    // slice() is temporary, so it does not mutate
+    const invalidValue = [...prevPath].reverse().reduce(setInvalidValuePart, value);
+    // If `formatInvalid` is supplied, we use it to format the invalid value
+    // before serializing it to TOML and printing it.
+    const formattedInvalidValue = typeof formatInvalid === 'function' ? formatInvalid(invalidValue) : invalidValue;
+    const invalidValueA = serializeToml(formattedInvalidValue);
+    return invalidValueA;
+};
+const setInvalidValuePart = function (value, part) {
+    if (Number.isInteger(part)) {
+        return [value];
+    }
+    return value === undefined ? {} : { [part]: value };
+};

package/lib/validate/helpers.js

@@ -0,0 +1,25 @@
+import isPlainObj from 'is-plain-obj';
+export const isArrayOfObjects = function (value) {
+    return Array.isArray(value) && value.every(isPlainObj);
+};
+export const isArrayOfStrings = function (value) {
+    return Array.isArray(value) && value.every(isString);
+};
+export const isString = function (value) {
+    return typeof value === 'string';
+};
+// Check an object valid properties, including legacy ones
+export const validProperties = function (propNames, legacyPropNames) {
+    return {
+        check: (value) => checkValidProperty(value, [...propNames, ...legacyPropNames]),
+        message: `has unknown properties. Valid properties are:
+${propNames.map((propName) => `  - ${propName}`).join('\n')}`,
+    };
+};
+const checkValidProperty = function (value, propNames) {
+    return Object.keys(value).every((propName) => propNames.includes(propName));
+};
+export const functionsDirectoryCheck = {
+    formatInvalid: ({ functionsDirectory } = {}) => ({ functions: { directory: functionsDirectory } }),
+    propertyName: 'functions.directory',
+};

package/{src → lib}/validate/identical.js

@@ -1,20 +1,16 @@
-import { throwUserError } from '../error.js'
-
+import { throwUserError } from '../error.js';
 // Validate that plugin are configured only once per origin
 // (`netlify.toml` or UI).
 // Exception: context-specific configuration since we allow context-specific
 // overrides. This does not validate them since contexts have not been merged
 // yet.
 export const validateIdenticalPlugins = function ({ plugins = [] }) {
-  plugins.filter(hasIdenticalPlugin).forEach(throwIndenticalPlugin)
-}
-
+    plugins.filter(hasIdenticalPlugin).forEach(throwIndenticalPlugin);
+};
 const hasIdenticalPlugin = function ({ package: packageName, origin }, index, plugins) {
-  return plugins.slice(index + 1).some((pluginA) => packageName === pluginA.package && origin === pluginA.origin)
-}
-
+    return plugins.slice(index + 1).some((pluginA) => packageName === pluginA.package && origin === pluginA.origin);
+};
 const throwIndenticalPlugin = function ({ package: packageName, origin }) {
-  throwUserError(`Plugin "${packageName}" must not be specified twice in ${ORIGINS[origin]}`)
-}
-
-const ORIGINS = { config: 'netlify.toml', ui: 'the app' }
+    throwUserError(`Plugin "${packageName}" must not be specified twice in ${ORIGINS[origin]}`);
+};
+const ORIGINS = { config: 'netlify.toml', ui: 'the app' };

package/lib/validate/main.js

@@ -0,0 +1,99 @@
+import { throwUserError } from '../error.js';
+import { THEME } from '../log/theme.js';
+import { getExample } from './example.js';
+import { PRE_CASE_NORMALIZE_VALIDATIONS, PRE_MERGE_VALIDATIONS, PRE_CONTEXT_VALIDATIONS, PRE_NORMALIZE_VALIDATIONS, POST_NORMALIZE_VALIDATIONS, } from './validations.js';
+// Validate the configuration file, before case normalization.
+export const validatePreCaseNormalize = function (config) {
+    validateConfig(config, PRE_CASE_NORMALIZE_VALIDATIONS);
+};
+// Validate the configuration file, before `defaultConfig` merge.
+export const validatePreMergeConfig = function (config) {
+    validateConfig(config, PRE_MERGE_VALIDATIONS);
+};
+// Validate the configuration file, before context merge.
+export const validatePreContextConfig = function (config) {
+    validateConfig(config, PRE_CONTEXT_VALIDATIONS);
+};
+// Validate the configuration file, before normalization.
+export const validatePreNormalizeConfig = function (config) {
+    validateConfig(config, PRE_NORMALIZE_VALIDATIONS);
+};
+// Validate the configuration file, after normalization.
+export const validatePostNormalizeConfig = function (config) {
+    validateConfig(config, POST_NORMALIZE_VALIDATIONS);
+};
+const validateConfig = function (config, validations) {
+    try {
+        validations.forEach(({ property, ...validation }) => {
+            validateProperty(config, { ...validation, nextPath: property.split('.') });
+        });
+    }
+    catch (error) {
+        throwUserError(error);
+    }
+};
+// Validate a single property in the configuration file.
+const validateProperty = function (parent, { nextPath: [propName, nextPropName, ...nextPath], prevPath = [propName], propPath = propName, key = propName, check, message, example, formatInvalid, propertyName, }) {
+    const value = parent[propName];
+    if (nextPropName !== undefined) {
+        return validateChild({
+            value,
+            nextPropName,
+            prevPath,
+            nextPath,
+            propPath,
+            key,
+            check,
+            message,
+            example,
+            formatInvalid,
+            propertyName,
+        });
+    }
+    if (value === undefined || (check !== undefined && check(value, key, prevPath))) {
+        return;
+    }
+    reportError({ prevPath, propPath, message, example, value, key, formatInvalid, propertyName });
+};
+const reportError = function ({ prevPath, propPath, message, example, value, key, formatInvalid, propertyName = propPath, }) {
+    throwUserError(`${THEME.highlightWords('Configuration property')} ${propertyName} ${message}
+${getExample({ value, key, prevPath, example, formatInvalid })}`);
+};
+// Recurse over children (each part of the `property` array).
+const validateChild = function ({ value, nextPropName, prevPath, nextPath, propPath, ...rest }) {
+    if (value === undefined) {
+        return;
+    }
+    if (nextPropName !== '*') {
+        return validateProperty(value, {
+            ...rest,
+            prevPath: [...prevPath, nextPropName],
+            nextPath: [nextPropName, ...nextPath],
+            propPath: `${propPath}.${nextPropName}`,
+            key: nextPropName,
+        });
+    }
+    return Object.keys(value).forEach((childProp) => {
+        validateChildProp({ childProp, value, nextPath, propPath, prevPath, ...rest });
+    });
+};
+// Can use * to recurse over array|object elements.
+const validateChildProp = function ({ childProp, value, nextPath, propPath, prevPath, ...rest }) {
+    if (Array.isArray(value)) {
+        const key = Number(childProp);
+        return validateProperty(value, {
+            ...rest,
+            prevPath: [...prevPath, key],
+            nextPath: [key, ...nextPath],
+            propPath: `${propPath}[${childProp}]`,
+            key,
+        });
+    }
+    validateProperty(value, {
+        ...rest,
+        prevPath: [...prevPath, childProp],
+        nextPath: [childProp, ...nextPath],
+        propPath: `${propPath}.${childProp}`,
+        key: childProp,
+    });
+};

package/lib/validate/validations.js

@@ -0,0 +1,275 @@
+import CronParser from 'cron-parser';
+import isPlainObj from 'is-plain-obj';
+import validateNpmPackageName from 'validate-npm-package-name';
+import { bundlers, WILDCARD_ALL as FUNCTIONS_CONFIG_WILDCARD_ALL } from '../functions_config.js';
+import { functionsDirectoryCheck, isArrayOfObjects, isArrayOfStrings, isString, validProperties } from './helpers.js';
+/**
+ * @param {string} cron
+ * @returns {boolean}
+ */
+const isValidCronExpression = (cron) => {
+    try {
+        CronParser.parseExpression(cron);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+// List of validations performed on the configuration file.
+// Validation are performed in order: parent should be before children.
+// Each validation is an object with the following properties:
+//   - `property` {string}: dot-delimited path to the property.
+//     Can contain `*` providing a previous check validates the parent is an
+//     object or an array.
+//   - `propertyName` {string}: human-friendly property name; overrides the
+//     value of `property` when displaying an error message
+//   - `check` {(value, key, prevPath) => boolean}: validation check function
+//   - `message` {string}: error message
+//   - `example` {string}: example of correct code
+//   - `formatInvalid` {(object) => object}: formats the invalid value when
+//     displaying an error message
+// We use this instead of JSON schema (or others) to get nicer error messages.
+// Validations done before case normalization
+export const PRE_CASE_NORMALIZE_VALIDATIONS = [
+    {
+        property: 'build',
+        check: isPlainObj,
+        message: 'must be a plain object.',
+        example: () => ({ build: { command: 'npm run build' } }),
+    },
+];
+// Properties with an `origin` property need to be validated twice:
+//  - Before the `origin` property is added
+//  - After `context.*` is merged, since they might contain that property
+const ORIGIN_VALIDATIONS = [
+    {
+        property: 'build.command',
+        check: isString,
+        message: 'must be a string',
+        example: () => ({ build: { command: 'npm run build' } }),
+    },
+    {
+        property: 'plugins',
+        check: isArrayOfObjects,
+        message: 'must be an array of objects.',
+        example: () => ({ plugins: [{ package: 'netlify-plugin-one' }, { package: 'netlify-plugin-two' }] }),
+    },
+];
+// Validations done before `defaultConfig` merge
+export const PRE_MERGE_VALIDATIONS = [...ORIGIN_VALIDATIONS];
+// Validations done before context merge
+export const PRE_CONTEXT_VALIDATIONS = [
+    {
+        property: 'context',
+        check: isPlainObj,
+        message: 'must be a plain object.',
+        example: () => ({ context: { production: { publish: 'dist' } } }),
+    },
+    {
+        property: 'context.*',
+        check: isPlainObj,
+        message: 'must be a plain object.',
+        example: (contextProps, key) => ({ context: { [key]: { publish: 'dist' } } }),
+    },
+];
+// Validations done before normalization
+export const PRE_NORMALIZE_VALIDATIONS = [
+    ...ORIGIN_VALIDATIONS,
+    {
+        property: 'functions',
+        check: isPlainObj,
+        message: 'must be an object.',
+        example: () => ({
+            functions: { external_node_modules: ['module-one', 'module-two'] },
+        }),
+    },
+    {
+        property: 'functions',
+        check: isPlainObj,
+        message: 'must be an object.',
+        example: () => ({
+            functions: { ignored_node_modules: ['module-one', 'module-two'] },
+        }),
+    },
+    {
+        property: 'edge_functions',
+        check: isArrayOfObjects,
+        message: 'must be an array of objects.',
+        example: () => ({
+            edge_functions: [
+                { path: '/hello', function: 'hello' },
+                { path: '/auth', function: 'auth' },
+            ],
+        }),
+    },
+];
+const EXAMPLE_PORT = 80;
+// Validations done after normalization
+export const POST_NORMALIZE_VALIDATIONS = [
+    {
+        property: 'plugins.*',
+        ...validProperties(['package', 'pinned_version', 'inputs'], ['origin']),
+        example: { plugins: [{ package: 'netlify-plugin-one', inputs: { port: EXAMPLE_PORT } }] },
+    },
+    {
+        property: 'plugins.*',
+        check: (plugin) => plugin.package !== undefined,
+        message: '"package" property is required.',
+        example: () => ({ plugins: [{ package: 'netlify-plugin-one' }] }),
+    },
+    {
+        property: 'plugins.*.package',
+        check: isString,
+        message: 'must be a string.',
+        example: () => ({ plugins: [{ package: 'netlify-plugin-one' }] }),
+    },
+    // We don't allow `package@tag|version` nor `git:...`, `github:...`,
+    // `https://...`, etc.
+    // We skip this validation for local plugins.
+    // We ensure @scope/plugin still work.
+    {
+        property: 'plugins.*.package',
+        check: (packageName) => packageName.startsWith('.') ||
+            packageName.startsWith('/') ||
+            validateNpmPackageName(packageName).validForOldPackages,
+        message: 'must be a npm package name only.',
+        example: () => ({ plugins: [{ package: 'netlify-plugin-one' }] }),
+    },
+    {
+        property: 'plugins.*.pinned_version',
+        check: isString,
+        message: 'must be a string.',
+        example: () => ({ plugins: [{ package: 'netlify-plugin-one', pinned_version: '1' }] }),
+    },
+    {
+        property: 'plugins.*.inputs',
+        check: isPlainObj,
+        message: 'must be a plain object.',
+        example: () => ({ plugins: [{ package: 'netlify-plugin-one', inputs: { port: EXAMPLE_PORT } }] }),
+    },
+    {
+        property: 'build.base',
+        check: isString,
+        message: 'must be a string.',
+        example: () => ({ build: { base: 'packages/project' } }),
+    },
+    {
+        property: 'build.publish',
+        check: isString,
+        message: 'must be a string.',
+        example: () => ({ build: { publish: 'dist' } }),
+    },
+    {
+        property: 'build.functions',
+        check: isString,
+        message: 'must be a string.',
+        example: () => ({ build: { functions: 'functions' } }),
+    },
+    {
+        property: 'build.edge_functions',
+        check: isString,
+        message: 'must be a string.',
+        example: () => ({ build: { edge_functions: 'edge-functions' } }),
+    },
+    {
+        property: 'functions.*',
+        check: isPlainObj,
+        message: 'must be an object.',
+        example: (value, key, prevPath) => ({
+            functions: { [prevPath[1]]: { external_node_modules: ['module-one', 'module-two'] } },
+        }),
+    },
+    {
+        property: 'functions.*.external_node_modules',
+        check: isArrayOfStrings,
+        message: 'must be an array of strings.',
+        example: (value, key, prevPath) => ({
+            functions: { [prevPath[1]]: { external_node_modules: ['module-one', 'module-two'] } },
+        }),
+    },
+    {
+        property: 'functions.*.ignored_node_modules',
+        check: isArrayOfStrings,
+        message: 'must be an array of strings.',
+        example: (value, key, prevPath) => ({
+            functions: { [prevPath[1]]: { ignored_node_modules: ['module-one', 'module-two'] } },
+        }),
+    },
+    {
+        property: 'functions.*.included_files',
+        check: isArrayOfStrings,
+        message: 'must be an array of strings.',
+        example: (value, key, prevPath) => ({
+            functions: { [prevPath[1]]: { included_files: ['directory-one/file1', 'directory-two/**/*.jpg'] } },
+        }),
+    },
+    {
+        property: 'functions.*.node_bundler',
+        check: (value) => bundlers.includes(value),
+        message: `must be one of: ${bundlers.join(', ')}`,
+        example: (value, key, prevPath) => ({
+            functions: { [prevPath[1]]: { node_bundler: bundlers[0] } },
+        }),
+    },
+    {
+        property: 'functions.*.directory',
+        check: (value, key, prevPath) => prevPath[1] === FUNCTIONS_CONFIG_WILDCARD_ALL,
+        message: 'must be defined on the main `functions` object.',
+        example: () => ({
+            functions: { directory: 'my-functions' },
+        }),
+    },
+    {
+        property: 'functions.*.schedule',
+        check: isValidCronExpression,
+        message: 'must be a valid cron expression (see https://ntl.fyi/cron-syntax).',
+        example: (value, key, prevPath) => ({
+            functions: { [prevPath[1]]: { schedule: '5 4 * * *' } },
+        }),
+    },
+    {
+        property: 'functionsDirectory',
+        check: isString,
+        message: 'must be a string.',
+        ...functionsDirectoryCheck,
+        example: () => ({
+            functions: { directory: 'my-functions' },
+        }),
+    },
+    {
+        property: 'edge_functions.*',
+        ...validProperties(['path', 'function'], []),
+        example: () => ({ edge_functions: [{ path: '/hello', function: 'hello' }] }),
+    },
+    {
+        property: 'edge_functions.*',
+        check: (edgeFunction) => edgeFunction.path !== undefined,
+        message: '"path" property is required.',
+        example: () => ({ edge_functions: [{ path: '/hello', function: 'hello' }] }),
+    },
+    {
+        property: 'edge_functions.*',
+        check: (edgeFunction) => edgeFunction.function !== undefined,
+        message: '"function" property is required.',
+        example: () => ({ edge_functions: [{ path: '/hello', function: 'hello' }] }),
+    },
+    {
+        property: 'edge_functions.*.path',
+        check: isString,
+        message: 'must be a string.',
+        example: () => ({ edge_functions: [{ path: '/hello', function: 'hello' }] }),
+    },
+    {
+        property: 'edge_functions.*.function',
+        check: isString,
+        message: 'must be a string.',
+        example: () => ({ edge_functions: [{ path: '/hello', function: 'hello' }] }),
+    },
+    {
+        property: 'edge_functions.*.path',
+        check: (pathName) => pathName.startsWith('/'),
+        message: 'must be a valid path.',
+        example: () => ({ edge_functions: [{ path: '/hello', function: 'hello' }] }),
+    },
+];

package/package.json

@@ -1,22 +1,27 @@
 {
   "name": "@netlify/config",
-  "version": "19.0.0-rc",
+  "version": "19.0.0",
   "description": "Netlify config module",
   "type": "module",
-  "exports": "./src/main.js",
-  "main": "./src/main.js",
+  "exports": "./lib/main.js",
+  "main": "./lib/main.js",
+  "types": "./lib/main.d.ts",
   "bin": {
-    "netlify-config": "src/bin/main.js"
+    "netlify-config": "./bin.js"
   },
   "files": [
-    "src/**/*.js"
+    "bin.js",
+    "lib/**/*.js"
   ],
   "author": "Netlify Inc.",
   "contributors": [
     "David Wells <hello@davidwells.io> (https://davidwells.io/)"
   ],
   "scripts": {
-    "prepublishOnly": "cd ../../ && npm run prepublishOnly"
+    "prebuild": "rm -rf lib",
+    "build": "tsc",
+    "test": "ava",
+    "test:ci": "c8 -r lcovonly -r text -r json ava"
   },
   "keywords": [
     "javascript",
@@ -64,9 +69,9 @@
     "is-plain-obj": "^4.0.0",
     "js-yaml": "^4.0.0",
     "map-obj": "^5.0.0",
-    "netlify": "^12.0.0",
-    "netlify-headers-parser": "^6.0.2",
-    "netlify-redirect-parser": "13.0.5",
+    "netlify": "^13.0.0",
+    "netlify-headers-parser": "^7.0.0",
+    "netlify-redirect-parser": "^14.0.0",
     "omit.js": "^2.0.2",
     "p-locate": "^6.0.0",
     "path-exists": "^5.0.0",
@@ -77,13 +82,17 @@
     "yargs": "^17.3.1"
   },
   "devDependencies": {
+    "@types/node": "^14.18.31",
     "ava": "^4.0.0",
+    "c8": "^7.12.0",
     "del": "^6.0.0",
     "has-ansi": "^5.0.0",
     "is-ci": "^3.0.0",
-    "tmp-promise": "^3.0.2"
+    "tmp-promise": "^3.0.2",
+    "typescript": "^4.8.4"
   },
   "engines": {
-    "node": "^12.20.0 || ^14.14.0 || >=16.0.0"
-  }
+    "node": "^14.16.0 || >=16.0.0"
+  },
+  "gitHead": "c4502f1c112e7f33d5e6fa053bfbe7dabdfe0160"
 }

package/src/api/build_settings.js

@@ -1,41 +0,0 @@
-import { removeFalsy } from '../utils/remove_falsy.js'
-
-// Netlify UI build settings are used as default configuration values in
-// production. In local builds, we retrieve them with `getSite` (`siteInfo`)
-// instead.
-// This also includes UI-installed plugins.
-export const addBuildSettings = function ({
-  defaultConfig,
-  baseRelDir,
-  siteInfo: { build_settings: buildSettings, plugins },
-}) {
-  if (buildSettings === undefined) {
-    return { defaultConfig, baseRelDir }
-  }
-
-  const defaultConfigA = getDefaultConfig(buildSettings, defaultConfig, plugins)
-  const baseRelDirA = getBaseRelDir(buildSettings, baseRelDir)
-  return { defaultConfig: defaultConfigA, baseRelDir: baseRelDirA }
-}
-
-// From the `getSite` API response to the corresponding configuration properties
-const getDefaultConfig = function (
-  { cmd: command, dir: publish, functions_dir: functionsDirectory, base },
-  { build, plugins = [], ...defaultConfig },
-  uiPlugins = [],
-) {
-  const siteBuild = removeFalsy({ command, publish, base })
-  const functions = functionsDirectory ? { functionsDirectory, functionsDirectoryOrigin: 'ui' } : {}
-  const uiPluginsA = uiPlugins.map(normalizeUiPlugin)
-  const pluginsA = [...uiPluginsA, ...plugins]
-  return { ...defaultConfig, build: { ...siteBuild, ...build }, plugins: pluginsA, ...functions }
-}
-
-// Make sure we know which fields we are picking from the API
-const normalizeUiPlugin = function ({ package: packageName, inputs, pinned_version: pinnedVersion }) {
-  return { package: packageName, inputs, pinned_version: pinnedVersion }
-}
-
-const getBaseRelDir = function ({ base_rel_dir: siteBaseRelDir }, baseRelDir = siteBaseRelDir) {
-  return Boolean(baseRelDir)
-}

package/src/api/client.js

@@ -1,15 +0,0 @@
-import { NetlifyAPI } from 'netlify'
-
-import { removeUndefined } from '../utils/remove_falsy.js'
-
-// Retrieve Netlify API client, if an access token was passed
-export const getApiClient = function ({ token, offline, testOpts = {}, host, scheme, pathPrefix }) {
-  if (!token || offline) {
-    return
-  }
-
-  // TODO: find less intrusive way to mock HTTP requests
-  const parameters = removeUndefined({ scheme: testOpts.scheme || scheme, host: testOpts.host || host, pathPrefix })
-  const api = new NetlifyAPI(token, parameters)
-  return api
-}