netlify-cli 17.3.1 → 17.4.0

package/src/lib/completion/generate-autocompletion.mjs

@@ -1,44 +1,41 @@
-// @ts-check
-import fs from 'fs'
-import { dirname } from 'path'
-
-import { sortOptions, warn } from '../../utils/command-helpers.mjs'
-
-import { AUTOCOMPLETION_FILE } from './constants.mjs'
-
+import fs from 'fs';
+import { dirname } from 'path';
+import { sortOptions, warn } from '../../utils/command-helpers.mjs';
+import { AUTOCOMPLETION_FILE } from './constants.mjs';
 /**
  * Create or updates the autocompletion information for the CLI
  * @param {import('../../commands/base-command.mjs').default} program
  * @returns {void}
  */
+// @ts-expect-error TS(7006) FIXME: Parameter 'program' implicitly has an 'any' type.
 const generateAutocompletion = (program) => {
-  try {
-    const autocomplete = program.commands.reduce(
-      (prev, cmd) => ({
-        ...prev,
-        [cmd.name()]: {
-          name: cmd.name(),
-          description: cmd.description().split('\n')[0],
-          options: cmd.options
-            .filter((option) => !option.hidden)
-            .sort(sortOptions)
-            .map((opt) => ({ name: `--${opt.name()}`, description: opt.description })),
-        },
-      }),
-      {},
-    )
-
-    if (!fs.existsSync(dirname(AUTOCOMPLETION_FILE))) {
-      fs.mkdirSync(dirname(AUTOCOMPLETION_FILE), { recursive: true })
+    try {
+        const autocomplete = program.commands.reduce(
+        // @ts-expect-error TS(7006) FIXME: Parameter 'prev' implicitly has an 'any' type.
+        (prev, cmd) => ({
+            ...prev,
+            [cmd.name()]: {
+                name: cmd.name(),
+                description: cmd.description().split('\n')[0],
+                options: cmd.options
+                    // @ts-expect-error TS(7006) FIXME: Parameter 'option' implicitly has an 'any' type.
+                    .filter((option) => !option.hidden)
+                    .sort(sortOptions)
+                    // @ts-expect-error TS(7006) FIXME: Parameter 'opt' implicitly has an 'any' type.
+                    .map((opt) => ({ name: `--${opt.name()}`, description: opt.description })),
+            },
+        }), {});
+        if (!fs.existsSync(dirname(AUTOCOMPLETION_FILE))) {
+            fs.mkdirSync(dirname(AUTOCOMPLETION_FILE), { recursive: true });
+        }
+        fs.writeFileSync(AUTOCOMPLETION_FILE, JSON.stringify(autocomplete), 'utf-8');
     }
-    fs.writeFileSync(AUTOCOMPLETION_FILE, JSON.stringify(autocomplete), 'utf-8')
-  } catch (error_) {
-    // Sometimes it can happen that the autocomplete generation in the postinstall script lacks permissions
-    // to write files to the home directory of the user. Therefore just warn with the error and don't break install.
-    if (error_ instanceof Error) {
-      warn(`could not create autocompletion.\n${error_.message}`)
+    catch (error_) {
+        // Sometimes it can happen that the autocomplete generation in the postinstall script lacks permissions
+        // to write files to the home directory of the user. Therefore just warn with the error and don't break install.
+        if (error_ instanceof Error) {
+            warn(`could not create autocompletion.\n${error_.message}`);
+        }
     }
-  }
-}
-
-export default generateAutocompletion
+};
+export default generateAutocompletion;

package/src/lib/completion/get-autocompletion.mjs

@@ -1,5 +1,3 @@
-// @ts-check
-
 /**
  * @typedef CompletionItem
  * @type import('tabtab').CompletionItem
@@ -10,39 +8,37 @@
  * @param {Record<string, CompletionItem & {options: CompletionItem[]}>} program
  * @returns {CompletionItem[]|void}
  */
+// @ts-expect-error TS(7006) FIXME: Parameter 'env' implicitly has an 'any' type.
 const getAutocompletion = function (env, program) {
-  if (!env.complete) {
-    return
-  }
-  // means that we are currently in the first command (the root command)
-  if (env.words === 1) {
-    const rootCommands = Object.values(program).map(({ description, name }) => ({ name, description }))
-
-    // suggest all commands
-    // $ netlify <cursor>
-    if (env.lastPartial.length === 0) {
-      return rootCommands
+    if (!env.complete) {
+        return;
     }
-
-    // $ netlify add<cursor>
-    // we can now check if a command starts with the last partial
-    const autocomplete = rootCommands.filter(({ name }) => name.startsWith(env.lastPartial))
-    return autocomplete
-  }
-
-  const [, command, ...args] = env.line.split(' ')
-
-  if (program[command]) {
-    const usedArgs = new Set(args)
-    const unusedOptions = program[command].options.filter(({ name }) => !usedArgs.has(name))
-
-    if (env.lastPartial.length !== 0) {
-      return unusedOptions.filter(({ name }) => name.startsWith(env.lastPartial))
+    // means that we are currently in the first command (the root command)
+    if (env.words === 1) {
+        // @ts-expect-error TS(2345) FIXME: Argument of type '({ description, name }: { descri... Remove this comment to see the full error message
+        const rootCommands = Object.values(program).map(({ description, name }) => ({ name, description }));
+        // suggest all commands
+        // $ netlify <cursor>
+        if (env.lastPartial.length === 0) {
+            return rootCommands;
+        }
+        // $ netlify add<cursor>
+        // we can now check if a command starts with the last partial
+        // @ts-expect-error TS(2769) FIXME: No overload matches this call.
+        const autocomplete = rootCommands.filter(({ name }) => name.startsWith(env.lastPartial));
+        return autocomplete;
     }
-
-    // suggest options that are not used
-    return unusedOptions
-  }
-}
-
-export default getAutocompletion
+    const [, command, ...args] = env.line.split(' ');
+    if (program[command]) {
+        const usedArgs = new Set(args);
+        // @ts-expect-error TS(7031) FIXME: Binding element 'name' implicitly has an 'any' typ... Remove this comment to see the full error message
+        const unusedOptions = program[command].options.filter(({ name }) => !usedArgs.has(name));
+        if (env.lastPartial.length !== 0) {
+            // @ts-expect-error TS(7031) FIXME: Binding element 'name' implicitly has an 'any' typ... Remove this comment to see the full error message
+            return unusedOptions.filter(({ name }) => name.startsWith(env.lastPartial));
+        }
+        // suggest options that are not used
+        return unusedOptions;
+    }
+};
+export default getAutocompletion;

package/src/lib/completion/index.mjs

@@ -1 +1 @@
-export { default as generateAutocompletion } from './generate-autocompletion.mjs'
+export { default as generateAutocompletion } from './generate-autocompletion.mjs';

package/src/lib/completion/script.mjs

@@ -1,17 +1,13 @@
 #!/usr/bin/env node
-// @ts-check
-
 // This script is run by the completion (every log output will be displayed on tab)
 // src/commands/completion/completion.mjs -> dynamically references this file
 // if this file is renamed or moved then it needs to be adapted there
-import { existsSync, readFileSync } from 'fs'
-import process from 'process'
-
-import { log, parseEnv } from 'tabtab'
-
-import { AUTOCOMPLETION_FILE } from './constants.mjs'
-import getAutocompletion from './get-autocompletion.mjs'
-
+import { existsSync, readFileSync } from 'fs';
+import process from 'process';
+// @ts-expect-error TS(7016) FIXME: Could not find a declaration file for module 'tabt... Remove this comment to see the full error message
+import { log, parseEnv } from 'tabtab';
+import { AUTOCOMPLETION_FILE } from './constants.mjs';
+import getAutocompletion from './get-autocompletion.mjs';
 /**
  * @typedef CompletionItem
  * @type import('tabtab').CompletionItem
@@ -22,14 +18,11 @@ import getAutocompletion from './get-autocompletion.mjs'
  * @param {Record<string, CompletionItem & {options: CompletionItem[]}>} program
  * @returns {CompletionItem[]|void}
  */
-
-const env = parseEnv(process.env)
-
+const env = parseEnv(process.env);
 if (existsSync(AUTOCOMPLETION_FILE)) {
-  const program = JSON.parse(readFileSync(AUTOCOMPLETION_FILE, 'utf-8'))
-  const autocomplete = getAutocompletion(env, program)
-
-  if (autocomplete && autocomplete.length !== 0) {
-    log(autocomplete)
-  }
+    const program = JSON.parse(readFileSync(AUTOCOMPLETION_FILE, 'utf-8'));
+    const autocomplete = getAutocompletion(env, program);
+    if (autocomplete && autocomplete.length !== 0) {
+        log(autocomplete);
+    }
 }

package/src/lib/edge-functions/bootstrap.mjs

@@ -1,5 +1,3 @@
-import { env } from 'process'
-
-const latestBootstrapURL = 'https://65437779a0c9990008b54abe--edge.netlify.com/bootstrap/index-combined.ts'
-
-export const getBootstrapURL = () => env.NETLIFY_EDGE_BOOTSTRAP || latestBootstrapURL
+import { env } from 'process';
+const latestBootstrapURL = 'https://65437779a0c9990008b54abe--edge.netlify.com/bootstrap/index-combined.ts';
+export const getBootstrapURL = () => env.NETLIFY_EDGE_BOOTSTRAP || latestBootstrapURL;

package/src/lib/edge-functions/consts.mjs

@@ -1,13 +1,12 @@
-export const DIST_IMPORT_MAP_PATH = 'edge-functions-import-map.json'
-export const INTERNAL_EDGE_FUNCTIONS_FOLDER = 'edge-functions'
-export const EDGE_FUNCTIONS_FOLDER = 'edge-functions-dist'
-export const EDGE_FUNCTIONS_SERVE_FOLDER = 'edge-functions-serve'
-export const PUBLIC_URL_PATH = '.netlify/internal/edge-functions'
-
+export const DIST_IMPORT_MAP_PATH = 'edge-functions-import-map.json';
+export const INTERNAL_EDGE_FUNCTIONS_FOLDER = 'edge-functions';
+export const EDGE_FUNCTIONS_FOLDER = 'edge-functions-dist';
+export const EDGE_FUNCTIONS_SERVE_FOLDER = 'edge-functions-serve';
+export const PUBLIC_URL_PATH = '.netlify/internal/edge-functions';
 // Feature flags related to Edge Functions that should be passed along to
 // Netlify Build.
 export const featureFlags = {
-  edge_functions_config_export: true,
-  edge_functions_npm_modules: true,
-  edge_functions_read_deno_config: true,
-}
+    edge_functions_config_export: true,
+    edge_functions_npm_modules: true,
+    edge_functions_read_deno_config: true,
+};

package/src/lib/edge-functions/deploy.mjs

@@ -1,44 +1,38 @@
-// @ts-check
-import { stat } from 'fs/promises'
-import { join } from 'path'
-
-import { getPathInProject } from '../settings.mjs'
-
-import { EDGE_FUNCTIONS_FOLDER, PUBLIC_URL_PATH } from './consts.mjs'
-
-const distPath = getPathInProject([EDGE_FUNCTIONS_FOLDER])
-
+import { stat } from 'fs/promises';
+import { join } from 'path';
+import { getPathInProject } from '../settings.mjs';
+import { EDGE_FUNCTIONS_FOLDER, PUBLIC_URL_PATH } from './consts.mjs';
+const distPath = getPathInProject([EDGE_FUNCTIONS_FOLDER]);
 /**
  * @param {string} workingDir
  * @param {*} file
  */
+// @ts-expect-error TS(7006) FIXME: Parameter 'workingDir' implicitly has an 'any' typ... Remove this comment to see the full error message
 export const deployFileNormalizer = (workingDir, file) => {
-  const absoluteDistPath = join(workingDir, distPath)
-  const isEdgeFunction = file.root === absoluteDistPath
-  const normalizedPath = isEdgeFunction ? `${PUBLIC_URL_PATH}/${file.normalizedPath}` : file.normalizedPath
-
-  return {
-    ...file,
-    normalizedPath,
-  }
-}
-
+    const absoluteDistPath = join(workingDir, distPath);
+    const isEdgeFunction = file.root === absoluteDistPath;
+    const normalizedPath = isEdgeFunction ? `${PUBLIC_URL_PATH}/${file.normalizedPath}` : file.normalizedPath;
+    return {
+        ...file,
+        normalizedPath,
+    };
+};
 /**
  * @param {string} workingDir
  */
+// @ts-expect-error TS(7006) FIXME: Parameter 'workingDir' implicitly has an 'any' typ... Remove this comment to see the full error message
 export const getDistPathIfExists = async (workingDir) => {
-  try {
-    const absoluteDistPath = join(workingDir, distPath)
-    const stats = await stat(absoluteDistPath)
-
-    if (!stats.isDirectory()) {
-      throw new Error(`Path ${absoluteDistPath} must be a directory.`)
+    try {
+        const absoluteDistPath = join(workingDir, distPath);
+        const stats = await stat(absoluteDistPath);
+        if (!stats.isDirectory()) {
+            throw new Error(`Path ${absoluteDistPath} must be a directory.`);
+        }
+        return absoluteDistPath;
     }
-
-    return absoluteDistPath
-  } catch {
-    // no-op
-  }
-}
-
-export const isEdgeFunctionFile = (filePath) => filePath.startsWith(`${PUBLIC_URL_PATH}/`)
+    catch {
+        // no-op
+    }
+};
+// @ts-expect-error TS(7006) FIXME: Parameter 'filePath' implicitly has an 'any' type.
+export const isEdgeFunctionFile = (filePath) => filePath.startsWith(`${PUBLIC_URL_PATH}/`);

package/src/lib/edge-functions/editor-helper.mjs

@@ -1,43 +1,30 @@
-import { env } from 'process'
-
-import inquirer from 'inquirer'
-
-import { runRecipe } from '../../commands/recipes/index.mjs'
-
-const STATE_PROMPT_PROPERTY = 'promptVSCodeSettings'
-
+import { env } from 'process';
+import inquirer from 'inquirer';
+import { runRecipe } from '../../commands/recipes/index.mjs';
+const STATE_PROMPT_PROPERTY = 'promptVSCodeSettings';
+// @ts-expect-error TS(7031) FIXME: Binding element 'NETLIFYDEVLOG' implicitly has an ... Remove this comment to see the full error message
 export const promptEditorHelper = async ({ NETLIFYDEVLOG, chalk, config, log, repositoryRoot, state }) => {
-  // This prevents tests from hanging when running them inside the VS Code
-  // terminal, as otherwise we'll show the prompt and wait for a response.
-  if (env.NODE_ENV === 'test') return
-
-  const isVSCode = env.TERM_PROGRAM === 'vscode'
-  const hasShownPrompt = Boolean(state.get(STATE_PROMPT_PROPERTY))
-  const hasEdgeFunctions = Boolean(config.edge_functions && config.edge_functions.length !== 0)
-
-  if (!isVSCode || hasShownPrompt || !hasEdgeFunctions) {
-    return
-  }
-
-  state.set(STATE_PROMPT_PROPERTY, true)
-
-  const message = 'Would you like to configure VS Code to use Edge Functions?'
-  const { confirm } = await inquirer.prompt({
-    type: 'confirm',
-    name: 'confirm',
-    message,
-    default: true,
-  })
-
-  if (!confirm) {
-    log(
-      `${NETLIFYDEVLOG} You can start this configuration manually by running ${chalk.magenta.bold(
-        'netlify recipes vscode',
-      )}.`,
-    )
-
-    return
-  }
-
-  await runRecipe({ config, recipeName: 'vscode', repositoryRoot })
-}
+    // This prevents tests from hanging when running them inside the VS Code
+    // terminal, as otherwise we'll show the prompt and wait for a response.
+    if (env.NODE_ENV === 'test')
+        return;
+    const isVSCode = env.TERM_PROGRAM === 'vscode';
+    const hasShownPrompt = Boolean(state.get(STATE_PROMPT_PROPERTY));
+    const hasEdgeFunctions = Boolean(config.edge_functions && config.edge_functions.length !== 0);
+    if (!isVSCode || hasShownPrompt || !hasEdgeFunctions) {
+        return;
+    }
+    state.set(STATE_PROMPT_PROPERTY, true);
+    const message = 'Would you like to configure VS Code to use Edge Functions?';
+    const { confirm } = await inquirer.prompt({
+        type: 'confirm',
+        name: 'confirm',
+        message,
+        default: true,
+    });
+    if (!confirm) {
+        log(`${NETLIFYDEVLOG} You can start this configuration manually by running ${chalk.magenta.bold('netlify recipes vscode')}.`);
+        return;
+    }
+    await runRecipe({ config, recipeName: 'vscode', repositoryRoot });
+};

package/src/lib/edge-functions/headers.mjs

@@ -1,24 +1,21 @@
-// @ts-check
-import { Buffer } from 'buffer'
-
+import { Buffer } from 'buffer';
 export const headers = {
-  BlobsInfo: 'x-nf-blobs-info',
-  DeployID: 'x-nf-deploy-id',
-  FeatureFlags: 'x-nf-feature-flags',
-  ForwardedHost: 'x-forwarded-host',
-  ForwardedProtocol: 'x-forwarded-proto',
-  Functions: 'x-nf-edge-functions',
-  InvocationMetadata: 'x-nf-edge-functions-metadata',
-  Geo: 'x-nf-geo',
-  Passthrough: 'x-nf-passthrough',
-  PassthroughHost: 'x-nf-passthrough-host',
-  PassthroughProtocol: 'x-nf-passthrough-proto',
-  IP: 'x-nf-client-connection-ip',
-  Site: 'X-NF-Site-Info',
-  DebugLogging: 'x-nf-debug-logging',
-  Account: 'x-nf-account-info',
-}
-
+    BlobsInfo: 'x-nf-blobs-info',
+    DeployID: 'x-nf-deploy-id',
+    FeatureFlags: 'x-nf-feature-flags',
+    ForwardedHost: 'x-forwarded-host',
+    ForwardedProtocol: 'x-forwarded-proto',
+    Functions: 'x-nf-edge-functions',
+    InvocationMetadata: 'x-nf-edge-functions-metadata',
+    Geo: 'x-nf-geo',
+    Passthrough: 'x-nf-passthrough',
+    PassthroughHost: 'x-nf-passthrough-host',
+    PassthroughProtocol: 'x-nf-passthrough-proto',
+    IP: 'x-nf-client-connection-ip',
+    Site: 'X-NF-Site-Info',
+    DebugLogging: 'x-nf-debug-logging',
+    Account: 'x-nf-account-info',
+};
 /**
  * Takes an array of feature flags and produces a Base64-encoded JSON object
  * that the bootstrap layer can understand.
@@ -26,12 +23,12 @@ export const headers = {
  * @param {Array<string>} featureFlags
  * @returns {string}
  */
+// @ts-expect-error TS(7006) FIXME: Parameter 'featureFlags' implicitly has an 'any' t... Remove this comment to see the full error message
 export const getFeatureFlagsHeader = (featureFlags) => {
-  const featureFlagsObject = featureFlags.reduce((acc, flagName) => ({ ...acc, [flagName]: true }), {})
-
-  return Buffer.from(JSON.stringify(featureFlagsObject)).toString('base64')
-}
-
+    // @ts-expect-error TS(7006) FIXME: Parameter 'acc' implicitly has an 'any' type.
+    const featureFlagsObject = featureFlags.reduce((acc, flagName) => ({ ...acc, [flagName]: true }), {});
+    return Buffer.from(JSON.stringify(featureFlagsObject)).toString('base64');
+};
 /**
  * Takes the invocation metadata object and produces a Base64-encoded JSON
  * object that the bootstrap layer can understand.
@@ -39,4 +36,5 @@ export const getFeatureFlagsHeader = (featureFlags) => {
  * @param {object} metadata
  * @returns {string}
  */
-export const getInvocationMetadataHeader = (metadata) => Buffer.from(JSON.stringify(metadata)).toString('base64')
+// @ts-expect-error TS(7006) FIXME: Parameter 'metadata' implicitly has an 'any' type.
+export const getInvocationMetadataHeader = (metadata) => Buffer.from(JSON.stringify(metadata)).toString('base64');

package/src/lib/edge-functions/internal.mjs

@@ -1,52 +1,46 @@
-// @ts-check
-import { readFile, stat } from 'fs/promises'
-import { dirname, join, resolve } from 'path'
-
-import { getPathInProject } from '../settings.mjs'
-
-import { INTERNAL_EDGE_FUNCTIONS_FOLDER } from './consts.mjs'
-
+import { readFile, stat } from 'fs/promises';
+import { dirname, join, resolve } from 'path';
+import { getPathInProject } from '../settings.mjs';
+import { INTERNAL_EDGE_FUNCTIONS_FOLDER } from './consts.mjs';
 /**
  * @param {string} workingDir
  */
+// @ts-expect-error TS(7006) FIXME: Parameter 'workingDir' implicitly has an 'any' typ... Remove this comment to see the full error message
 export const getInternalFunctions = async (workingDir) => {
-  const path = join(workingDir, getPathInProject([INTERNAL_EDGE_FUNCTIONS_FOLDER]))
-
-  try {
-    const stats = await stat(path)
-
-    if (!stats.isDirectory()) {
-      throw new Error('Internal edge functions directory expected')
+    const path = join(workingDir, getPathInProject([INTERNAL_EDGE_FUNCTIONS_FOLDER]));
+    try {
+        const stats = await stat(path);
+        if (!stats.isDirectory()) {
+            throw new Error('Internal edge functions directory expected');
+        }
     }
-  } catch {
-    return {
-      functions: [],
-      path: null,
+    catch {
+        return {
+            functions: [],
+            path: null,
+        };
     }
-  }
-
-  try {
-    const manifestPath = join(path, 'manifest.json')
-    const manifest = JSON.parse(await readFile(manifestPath))
-
-    if (manifest.version !== 1) {
-      throw new Error('Unsupported manifest format')
+    try {
+        const manifestPath = join(path, 'manifest.json');
+        // @ts-expect-error TS(2345) FIXME: Argument of type 'Buffer' is not assignable to par... Remove this comment to see the full error message
+        const manifest = JSON.parse(await readFile(manifestPath));
+        if (manifest.version !== 1) {
+            throw new Error('Unsupported manifest format');
+        }
+        const data = {
+            functions: manifest.functions || [],
+            path,
+        };
+        if (manifest.import_map) {
+            // @ts-expect-error TS(2339) FIXME: Property 'importMap' does not exist on type '{ fun... Remove this comment to see the full error message
+            data.importMap = resolve(dirname(manifestPath), manifest.import_map);
+        }
+        return data;
     }
-
-    const data = {
-      functions: manifest.functions || [],
-      path,
+    catch {
+        return {
+            functions: [],
+            path,
+        };
     }
-
-    if (manifest.import_map) {
-      data.importMap = resolve(dirname(manifestPath), manifest.import_map)
-    }
-
-    return data
-  } catch {
-    return {
-      functions: [],
-      path,
-    }
-  }
-}
+};