netlify-cli 17.3.1 → 17.4.0

package/src/utils/env/index.mjs

@@ -1,56 +1,57 @@
-import { error } from '../command-helpers.mjs'
-
-export const AVAILABLE_CONTEXTS = ['all', 'production', 'deploy-preview', 'branch-deploy', 'dev']
-export const AVAILABLE_SCOPES = ['builds', 'functions', 'runtime', 'post_processing']
-
+import { error } from '../command-helpers.mjs';
+export const AVAILABLE_CONTEXTS = ['all', 'production', 'deploy-preview', 'branch-deploy', 'dev'];
+export const AVAILABLE_SCOPES = ['builds', 'functions', 'runtime', 'post_processing'];
 /**
  * @param {string|undefined} context - The deploy context or branch of the environment variable value
  * @returns {Array<string|undefined>} The normalized context or branch name
  */
+// @ts-expect-error TS(7006) FIXME: Parameter 'context' implicitly has an 'any' type.
 export const normalizeContext = (context) => {
-  if (!context) {
-    return context
-  }
-  const CONTEXT_SYNONYMS = {
-    dp: 'deploy-preview',
-    prod: 'production',
-  }
-  context = context.toLowerCase()
-  if (context in CONTEXT_SYNONYMS) {
-    context = CONTEXT_SYNONYMS[context]
-  }
-  const forbiddenContexts = AVAILABLE_CONTEXTS.map((ctx) => `branch:${ctx}`)
-  if (forbiddenContexts.includes(context)) {
-    error(`The context ${context} includes a reserved keyword and is not allowed`)
-  }
-  context = context.replace(/^branch:/, '')
-  return context
-}
-
+    if (!context) {
+        return context;
+    }
+    const CONTEXT_SYNONYMS = {
+        dp: 'deploy-preview',
+        prod: 'production',
+    };
+    context = context.toLowerCase();
+    if (context in CONTEXT_SYNONYMS) {
+        // @ts-expect-error TS(7053) FIXME: Element implicitly has an 'any' type because expre... Remove this comment to see the full error message
+        context = CONTEXT_SYNONYMS[context];
+    }
+    const forbiddenContexts = AVAILABLE_CONTEXTS.map((ctx) => `branch:${ctx}`);
+    if (forbiddenContexts.includes(context)) {
+        error(`The context ${context} includes a reserved keyword and is not allowed`);
+    }
+    context = context.replace(/^branch:/, '');
+    return context;
+};
 /**
  * Finds a matching environment variable value from a given context
  * @param {Array<object>} values - An array of environment variable values from Envelope
  * @param {string} context - The deploy context or branch of the environment variable value
  * @returns {object<context: enum<dev,branch-deploy,deploy-preview,production,branch>, context_parameter: <string>, value: string>} The matching environment variable value object
  */
-export const findValueInValues = (values, context) =>
-  values.find((val) => {
+// @ts-expect-error TS(7006) FIXME: Parameter 'values' implicitly has an 'any' type.
+export const findValueInValues = (values, context) => 
+// @ts-expect-error TS(7006) FIXME: Parameter 'val' implicitly has an 'any' type.
+values.find((val) => {
     if (!AVAILABLE_CONTEXTS.includes(context)) {
-      // the "context" option passed in is actually the name of a branch
-      return val.context === 'all' || val.context_parameter === context
+        // the "context" option passed in is actually the name of a branch
+        return val.context === 'all' || val.context_parameter === context;
     }
-    return [context, 'all'].includes(val.context)
-  })
-
+    return [context, 'all'].includes(val.context);
+});
 /**
  * Finds environment variables that match a given source
  * @param {object} env - The dictionary of environment variables
  * @param {enum<general,account,addons,ui,configFile>} source - The source of the environment variable
  * @returns {object} The dictionary of env vars that match the given source
  */
-export const filterEnvBySource = (env, source) =>
-  Object.fromEntries(Object.entries(env).filter(([, variable]) => variable.sources[0] === source))
-
+// @ts-expect-error TS(7006) FIXME: Parameter 'env' implicitly has an 'any' type.
+export const filterEnvBySource = (env, source) => 
+// @ts-expect-error TS(2571) FIXME: Object is of type 'unknown'.
+Object.fromEntries(Object.entries(env).filter(([, variable]) => variable.sources[0] === source));
 /**
  * Fetches data from Envelope
  * @param {string} accountId - The account id
@@ -59,26 +60,27 @@ export const filterEnvBySource = (env, source) =>
  * @param {string} siteId - The site id
  * @returns {Array<object>} An array of environment variables from the Envelope service
  */
+// @ts-expect-error TS(7031) FIXME: Binding element 'accountId' implicitly has an 'any... Remove this comment to see the full error message
 const fetchEnvelopeItems = async function ({ accountId, api, key, siteId }) {
-  if (accountId === undefined) {
-    return {}
-  }
-  try {
-    // if a single key is passed, fetch that single env var
-    if (key) {
-      const envelopeItem = await api.getEnvVar({ accountId, key, siteId })
-      return [envelopeItem]
+    if (accountId === undefined) {
+        return {};
+    }
+    try {
+        // if a single key is passed, fetch that single env var
+        if (key) {
+            const envelopeItem = await api.getEnvVar({ accountId, key, siteId });
+            return [envelopeItem];
+        }
+        // otherwise, fetch the entire list of env vars
+        const envelopeItems = await api.getEnvVars({ accountId, siteId });
+        return envelopeItems;
+    }
+    catch {
+        // Collaborators aren't allowed to read shared env vars,
+        // so return an empty array silently in that case
+        return [];
     }
-    // otherwise, fetch the entire list of env vars
-    const envelopeItems = await api.getEnvVars({ accountId, siteId })
-    return envelopeItems
-  } catch {
-    // Collaborators aren't allowed to read shared env vars,
-    // so return an empty array silently in that case
-    return []
-  }
-}
-
+};
 /**
  * Filters and sorts data from Envelope by a given context and/or scope
  * @param {string} context - The deploy context or branch of the environment variable value
@@ -102,29 +104,33 @@ const fetchEnvelopeItems = async function ({ accountId, api, key, siteId }) {
  *   },
  * }
  */
-export const formatEnvelopeData = ({ context = 'dev', envelopeItems = [], scope = 'any', source }) =>
-  envelopeItems
+// @ts-expect-error TS(7031) FIXME: Binding element 'source' implicitly has an 'any' t... Remove this comment to see the full error message
+export const formatEnvelopeData = ({ context = 'dev', envelopeItems = [], scope = 'any', source }) => envelopeItems
     // filter by context
     .filter(({ values }) => Boolean(findValueInValues(values, context)))
     // filter by scope
+    // @ts-expect-error TS(2339) FIXME: Property 'includes' does not exist on type 'never'... Remove this comment to see the full error message
     .filter(({ scopes }) => (scope === 'any' ? true : scopes.includes(scope)))
     // sort alphabetically, case insensitive
+    // @ts-expect-error TS(2339) FIXME: Property 'key' does not exist on type 'never'.
     .sort((left, right) => (left.key.toLowerCase() < right.key.toLowerCase() ? -1 : 1))
     // format the data
     .reduce((acc, cur) => {
-      const { context: ctx, context_parameter: branch, value } = findValueInValues(cur.values, context)
-      return {
+    // @ts-expect-error TS(2339) FIXME: Property 'values' does not exist on type 'never'.
+    const { context: ctx, context_parameter: branch, value } = findValueInValues(cur.values, context);
+    return {
         ...acc,
+        // @ts-expect-error TS(2339) FIXME: Property 'key' does not exist on type 'never'.
         [cur.key]: {
-          context: ctx,
-          branch,
-          scopes: cur.scopes,
-          sources: [source],
-          value,
+            context: ctx,
+            branch,
+            // @ts-expect-error TS(2339) FIXME: Property 'scopes' does not exist on type 'never'.
+            scopes: cur.scopes,
+            sources: [source],
+            value,
         },
-      }
-    }, {})
-
+    };
+}, {});
 /**
  * Collects env vars from multiple sources and arranges them in the correct order of precedence
  * @param {object} api - The api singleton object
@@ -136,109 +142,103 @@ export const formatEnvelopeData = ({ context = 'dev', envelopeItems = [], scope
  * @param {object} siteInfo - The site object
  * @returns {object} An object of environment variables keys and their metadata
  */
+// @ts-expect-error TS(7031) FIXME: Binding element 'api' implicitly has an 'any' type... Remove this comment to see the full error message
 export const getEnvelopeEnv = async ({ api, context = 'dev', env, key = '', raw = false, scope = 'any', siteInfo }) => {
-  const { account_slug: accountId, id: siteId } = siteInfo
-
-  const [accountEnvelopeItems, siteEnvelopeItems] = await Promise.all([
-    fetchEnvelopeItems({ api, accountId, key }),
-    fetchEnvelopeItems({ api, accountId, key, siteId }),
-  ])
-
-  const accountEnv = formatEnvelopeData({ context, envelopeItems: accountEnvelopeItems, scope, source: 'account' })
-  const siteEnv = formatEnvelopeData({ context, envelopeItems: siteEnvelopeItems, scope, source: 'ui' })
-
-  if (raw) {
-    const entries = Object.entries({ ...accountEnv, ...siteEnv })
-    return entries.reduce(
-      (obj, [envVarKey, metadata]) => ({
-        ...obj,
-        [envVarKey]: metadata.value,
-      }),
-      {},
-    )
-  }
-
-  const generalEnv = filterEnvBySource(env, 'general')
-  const internalEnv = filterEnvBySource(env, 'internal')
-  const addonsEnv = filterEnvBySource(env, 'addons')
-  const configFileEnv = filterEnvBySource(env, 'configFile')
-
-  // filter out configFile env vars if a non-configFile scope is passed
-  const includeConfigEnvVars = /any|builds|post[-_]processing/.test(scope)
-
-  // Sources of environment variables, in ascending order of precedence.
-  return {
-    ...generalEnv,
-    ...accountEnv,
-    ...(includeConfigEnvVars ? addonsEnv : {}),
-    ...siteEnv,
-    ...(includeConfigEnvVars ? configFileEnv : {}),
-    ...internalEnv,
-  }
-}
-
+    const { account_slug: accountId, id: siteId } = siteInfo;
+    const [accountEnvelopeItems, siteEnvelopeItems] = await Promise.all([
+        // @ts-expect-error TS(2345) FIXME: Argument of type '{ api: any; accountId: any; key:... Remove this comment to see the full error message
+        fetchEnvelopeItems({ api, accountId, key }),
+        fetchEnvelopeItems({ api, accountId, key, siteId }),
+    ]);
+    const accountEnv = formatEnvelopeData({ context, envelopeItems: accountEnvelopeItems, scope, source: 'account' });
+    const siteEnv = formatEnvelopeData({ context, envelopeItems: siteEnvelopeItems, scope, source: 'ui' });
+    if (raw) {
+        const entries = Object.entries({ ...accountEnv, ...siteEnv });
+        return entries.reduce((obj, [envVarKey, metadata]) => ({
+            ...obj,
+            // @ts-expect-error TS(2571) FIXME: Object is of type 'unknown'.
+            [envVarKey]: metadata.value,
+        }), {});
+    }
+    const generalEnv = filterEnvBySource(env, 'general');
+    const internalEnv = filterEnvBySource(env, 'internal');
+    const addonsEnv = filterEnvBySource(env, 'addons');
+    const configFileEnv = filterEnvBySource(env, 'configFile');
+    // filter out configFile env vars if a non-configFile scope is passed
+    const includeConfigEnvVars = /any|builds|post[-_]processing/.test(scope);
+    // Sources of environment variables, in ascending order of precedence.
+    return {
+        ...generalEnv,
+        ...accountEnv,
+        ...(includeConfigEnvVars ? addonsEnv : {}),
+        ...siteEnv,
+        ...(includeConfigEnvVars ? configFileEnv : {}),
+        ...internalEnv,
+    };
+};
 /**
  * Returns a human-readable, comma-separated list of scopes
  * @param {Array<enum<builds,functions,runtime,post_processing>>} scopes - An array of scopes
  * @returns {string} A human-readable, comma-separated list of scopes
  */
+// @ts-expect-error TS(7006) FIXME: Parameter 'scopes' implicitly has an 'any' type.
 export const getHumanReadableScopes = (scopes) => {
-  const HUMAN_SCOPES = ['Builds', 'Functions', 'Runtime', 'Post processing']
-  const SCOPES_MAP = {
-    builds: HUMAN_SCOPES[0],
-    functions: HUMAN_SCOPES[1],
-    runtime: HUMAN_SCOPES[2],
-    post_processing: HUMAN_SCOPES[3],
-    'post-processing': HUMAN_SCOPES[3],
-  }
-  if (!scopes) {
-    // if `scopes` is not available, the env var comes from netlify.toml
-    // env vars specified in netlify.toml are present in the `builds` and `post_processing` scope
-    return 'Builds, Post processing'
-  }
-  if (scopes.length === Object.keys(HUMAN_SCOPES).length) {
-    // shorthand instead of listing every available scope
-    return 'All'
-  }
-  return scopes.map((scope) => SCOPES_MAP[scope]).join(', ')
-}
-
+    const HUMAN_SCOPES = ['Builds', 'Functions', 'Runtime', 'Post processing'];
+    const SCOPES_MAP = {
+        builds: HUMAN_SCOPES[0],
+        functions: HUMAN_SCOPES[1],
+        runtime: HUMAN_SCOPES[2],
+        post_processing: HUMAN_SCOPES[3],
+        'post-processing': HUMAN_SCOPES[3],
+    };
+    if (!scopes) {
+        // if `scopes` is not available, the env var comes from netlify.toml
+        // env vars specified in netlify.toml are present in the `builds` and `post_processing` scope
+        return 'Builds, Post processing';
+    }
+    if (scopes.length === Object.keys(HUMAN_SCOPES).length) {
+        // shorthand instead of listing every available scope
+        return 'All';
+    }
+    // @ts-expect-error TS(7006) FIXME: Parameter 'scope' implicitly has an 'any' type.
+    return scopes.map((scope) => SCOPES_MAP[scope]).join(', ');
+};
 /**
  * Translates a Mongo env into an Envelope env
  * @param {object} env - The site's env as it exists in Mongo
  * @returns {Array<object>} The array of Envelope env vars
  */
 export const translateFromMongoToEnvelope = (env = {}) => {
-  const envVars = Object.entries(env).map(([key, value]) => ({
-    key,
-    scopes: AVAILABLE_SCOPES,
-    values: [
-      {
-        context: 'all',
-        value,
-      },
-    ],
-  }))
-
-  return envVars
-}
-
+    const envVars = Object.entries(env).map(([key, value]) => ({
+        key,
+        scopes: AVAILABLE_SCOPES,
+        values: [
+            {
+                context: 'all',
+                value,
+            },
+        ],
+    }));
+    return envVars;
+};
 /**
  * Translates an Envelope env into a Mongo env
  * @param {Array<object>} envVars - The array of Envelope env vars
  * @param {string} context - The deploy context or branch of the environment variable
  * @returns {object} The env object as compatible with Mongo
  */
-export const translateFromEnvelopeToMongo = (envVars = [], context = 'dev') =>
-  envVars
+export const translateFromEnvelopeToMongo = (envVars = [], context = 'dev') => envVars
+    // @ts-expect-error TS(2339) FIXME: Property 'key' does not exist on type 'never'.
     .sort((left, right) => (left.key.toLowerCase() < right.key.toLowerCase() ? -1 : 1))
     .reduce((acc, cur) => {
-      const envVar = cur.values.find((val) => [context, 'all'].includes(val.context_parameter || val.context))
-      if (envVar && envVar.value) {
+    // @ts-expect-error TS(2339) FIXME: Property 'values' does not exist on type 'never'.
+    const envVar = cur.values.find((val) => [context, 'all'].includes(val.context_parameter || val.context));
+    if (envVar && envVar.value) {
         return {
-          ...acc,
-          [cur.key]: envVar.value,
-        }
-      }
-      return acc
-    }, {})
+            ...acc,
+            // @ts-expect-error TS(2339) FIXME: Property 'key' does not exist on type 'never'.
+            [cur.key]: envVar.value,
+        };
+    }
+    return acc;
+}, {});

package/src/utils/execa.mjs

@@ -1,22 +1,18 @@
-import { env } from 'process'
-
-import execaLib from 'execa'
-
+import { env } from 'process';
+import execaLib from 'execa';
 // This is a thin layer on top of `execa` that allows consumers to provide an
 // alternative path to the module location, making it easier to mock its logic
 // in tests (see `tests/utils/mock-execa.js`).
-
 /**
  * @type {import('execa')}
  */
 // eslint-disable-next-line import/no-mutable-exports
-let execa
-
+let execa;
 if (env.NETLIFY_CLI_EXECA_PATH) {
-  const execaMock = await import(env.NETLIFY_CLI_EXECA_PATH)
-  execa = execaMock.default
-} else {
-  execa = execaLib
+    const execaMock = await import(env.NETLIFY_CLI_EXECA_PATH);
+    execa = execaMock.default;
 }
-
-export default execa
+else {
+    execa = execaLib;
+}
+export default execa;

package/src/utils/feature-flags.mjs

@@ -11,9 +11,10 @@
  *
  * @returns {boolean}
  */
+// @ts-expect-error TS(7006) FIXME: Parameter 'flagName' implicitly has an 'any' type.
 export const isFeatureFlagEnabled = (flagName, siteInfo) => {
-  if (siteInfo.feature_flags && siteInfo.feature_flags[flagName] !== false) {
-    return true
-  }
-  return false
-}
+    if (siteInfo.feature_flags && siteInfo.feature_flags[flagName] !== false) {
+        return true;
+    }
+    return false;
+};

package/src/utils/framework-server.mjs

@@ -1,20 +1,14 @@
-// @ts-check
-import waitPort from 'wait-port'
-
-import { startSpinner, stopSpinner } from '../lib/spinner.mjs'
-
-import { error, exit, log, NETLIFYDEVERR, NETLIFYDEVLOG } from './command-helpers.mjs'
-import { runCommand } from './shell.mjs'
-import { startStaticServer } from './static-server.mjs'
-
+import waitPort from 'wait-port';
+import { startSpinner, stopSpinner } from '../lib/spinner.mjs';
+import { error, exit, log, NETLIFYDEVERR, NETLIFYDEVLOG } from './command-helpers.mjs';
+import { runCommand } from './shell.mjs';
+import { startStaticServer } from './static-server.mjs';
 // 10 minutes
-const FRAMEWORK_PORT_TIMEOUT = 6e5
-
+const FRAMEWORK_PORT_TIMEOUT = 6e5;
 /**
  * @typedef StartReturnObject
  * @property {4 | 6 | undefined=} ipVersion The version the open port was found on
  */
-
 /**
  * Start a static server if the `useStaticServer` is provided or a framework specific server
  * @param {object} config
@@ -22,46 +16,43 @@ const FRAMEWORK_PORT_TIMEOUT = 6e5
  * @param {string} config.cwd
  * @returns {Promise<StartReturnObject>}
  */
+// @ts-expect-error TS(7031) FIXME: Binding element 'cwd' implicitly has an 'any' type... Remove this comment to see the full error message
 export const startFrameworkServer = async function ({ cwd, settings }) {
-  if (settings.useStaticServer) {
-    if (settings.command) {
-      runCommand(settings.command, { env: settings.env, cwd })
+    if (settings.useStaticServer) {
+        if (settings.command) {
+            runCommand(settings.command, { env: settings.env, cwd });
+        }
+        await startStaticServer({ settings });
+        return {};
     }
-    await startStaticServer({ settings })
-
-    return {}
-  }
-
-  log(`${NETLIFYDEVLOG} Starting Netlify Dev with ${settings.framework || 'custom config'}`)
-
-  const spinner = startSpinner({
-    text: `Waiting for framework port ${settings.frameworkPort}. This can be configured using the 'targetPort' property in the netlify.toml`,
-  })
-
-  runCommand(settings.command, { env: settings.env, spinner, cwd })
-
-  let port
-  try {
-    port = await waitPort({
-      port: settings.frameworkPort,
-      host: 'localhost',
-      output: 'silent',
-      timeout: FRAMEWORK_PORT_TIMEOUT,
-      ...(settings.pollingStrategies?.includes('HTTP') && { protocol: 'http' }),
-    })
-
-    if (!port.open) {
-      throw new Error(`Timed out waiting for port '${settings.frameworkPort}' to be open`)
+    log(`${NETLIFYDEVLOG} Starting Netlify Dev with ${settings.framework || 'custom config'}`);
+    const spinner = startSpinner({
+        text: `Waiting for framework port ${settings.frameworkPort}. This can be configured using the 'targetPort' property in the netlify.toml`,
+    });
+    runCommand(settings.command, { env: settings.env, spinner, cwd });
+    let port;
+    try {
+        port = await waitPort({
+            port: settings.frameworkPort,
+            host: 'localhost',
+            output: 'silent',
+            timeout: FRAMEWORK_PORT_TIMEOUT,
+            ...(settings.pollingStrategies?.includes('HTTP') && { protocol: 'http' }),
+        });
+        if (!port.open) {
+            throw new Error(`Timed out waiting for port '${settings.frameworkPort}' to be open`);
+        }
+        // @ts-expect-error TS(2345) FIXME: Argument of type '{ error: boolean; spinner: Ora; ... Remove this comment to see the full error message
+        stopSpinner({ error: false, spinner });
     }
-
-    stopSpinner({ error: false, spinner })
-  } catch (error_) {
-    stopSpinner({ error: true, spinner })
-    log(NETLIFYDEVERR, `Netlify Dev could not start or connect to localhost:${settings.frameworkPort}.`)
-    log(NETLIFYDEVERR, `Please make sure your framework server is running on port ${settings.frameworkPort}`)
-    error(error_)
-    exit(1)
-  }
-
-  return { ipVersion: port?.ipVersion }
-}
+    catch (error_) {
+        // @ts-expect-error TS(2345) FIXME: Argument of type '{ error: boolean; spinner: Ora; ... Remove this comment to see the full error message
+        stopSpinner({ error: true, spinner });
+        log(NETLIFYDEVERR, `Netlify Dev could not start or connect to localhost:${settings.frameworkPort}.`);
+        log(NETLIFYDEVERR, `Please make sure your framework server is running on port ${settings.frameworkPort}`);
+        // @ts-expect-error TS(2345) FIXME: Argument of type 'unknown' is not assignable to pa... Remove this comment to see the full error message
+        error(error_);
+        exit(1);
+    }
+    return { ipVersion: port?.ipVersion };
+};

package/src/utils/functions/constants.mjs

@@ -1 +1 @@
-export const CLOCKWORK_USERAGENT = 'Netlify Clockwork'
+export const CLOCKWORK_USERAGENT = 'Netlify Clockwork';

package/src/utils/functions/functions.mjs

@@ -1,13 +1,9 @@
-// @ts-check
-import { promises as fs } from 'fs'
-import { resolve } from 'path'
-
-import { isDirectoryAsync, isFileAsync } from '../../lib/fs.mjs'
-import { getPathInProject } from '../../lib/settings.mjs'
-
-export const INTERNAL_FUNCTIONS_FOLDER = 'functions-internal'
-export const SERVE_FUNCTIONS_FOLDER = 'functions-serve'
-
+import { promises as fs } from 'fs';
+import { resolve } from 'path';
+import { isDirectoryAsync, isFileAsync } from '../../lib/fs.mjs';
+import { getPathInProject } from '../../lib/settings.mjs';
+export const INTERNAL_FUNCTIONS_FOLDER = 'functions-internal';
+export const SERVE_FUNCTIONS_FOLDER = 'functions-serve';
 /**
  * retrieves the function directory out of the flags or config
  * @param {object} param
@@ -16,29 +12,25 @@ export const SERVE_FUNCTIONS_FOLDER = 'functions-serve'
  * @param {string} [defaultValue]
  * @returns {string}
  */
-export const getFunctionsDir = ({ config, options }, defaultValue) =>
-  options.functions || config.dev?.functions || config.functionsDirectory || config.dev?.Functions || defaultValue
-
+// @ts-expect-error TS(7031) FIXME: Binding element 'config' implicitly has an 'any' t... Remove this comment to see the full error message
+export const getFunctionsDir = ({ config, options }, defaultValue) => options.functions || config.dev?.functions || config.functionsDirectory || config.dev?.Functions || defaultValue;
+// @ts-expect-error TS(7031) FIXME: Binding element 'base' implicitly has an 'any' typ... Remove this comment to see the full error message
 export const getFunctionsManifestPath = async ({ base, packagePath = '' }) => {
-  const path = resolve(base, packagePath, getPathInProject(['functions', 'manifest.json']))
-  const isFile = await isFileAsync(path)
-
-  return isFile ? path : null
-}
-
+    const path = resolve(base, packagePath, getPathInProject(['functions', 'manifest.json']));
+    const isFile = await isFileAsync(path);
+    return isFile ? path : null;
+};
+// @ts-expect-error TS(7031) FIXME: Binding element 'base' implicitly has an 'any' typ... Remove this comment to see the full error message
 export const getFunctionsDistPath = async ({ base, packagePath = '' }) => {
-  const path = resolve(base, packagePath, getPathInProject(['functions']))
-  const isDirectory = await isDirectoryAsync(path)
-
-  return isDirectory ? path : null
-}
-
+    const path = resolve(base, packagePath, getPathInProject(['functions']));
+    const isDirectory = await isDirectoryAsync(path);
+    return isDirectory ? path : null;
+};
+// @ts-expect-error TS(7031) FIXME: Binding element 'base' implicitly has an 'any' typ... Remove this comment to see the full error message
 export const getFunctionsServePath = ({ base, packagePath = '' }) => {
-  const path = resolve(base, packagePath, getPathInProject([SERVE_FUNCTIONS_FOLDER]))
-
-  return path
-}
-
+    const path = resolve(base, packagePath, getPathInProject([SERVE_FUNCTIONS_FOLDER]));
+    return path;
+};
 /**
  * Retrieves the internal functions directory and creates it if ensureExists is provided
  * @param {object} config
@@ -47,14 +39,12 @@ export const getFunctionsServePath = ({ base, packagePath = '' }) => {
  * @param {string} config.packagePath
  * @returns
  */
+// @ts-expect-error TS(7031) FIXME: Binding element 'base' implicitly has an 'any' typ... Remove this comment to see the full error message
 export const getInternalFunctionsDir = async ({ base, ensureExists, packagePath = '' }) => {
-  const path = resolve(base, packagePath, getPathInProject([INTERNAL_FUNCTIONS_FOLDER]))
-
-  if (ensureExists) {
-    await fs.mkdir(path, { recursive: true })
-  }
-
-  const isDirectory = await isDirectoryAsync(path)
-
-  return isDirectory ? path : null
-}
+    const path = resolve(base, packagePath, getPathInProject([INTERNAL_FUNCTIONS_FOLDER]));
+    if (ensureExists) {
+        await fs.mkdir(path, { recursive: true });
+    }
+    const isDirectory = await isDirectoryAsync(path);
+    return isDirectory ? path : null;
+};