serverless-heaven / serverless-webpack / 24743128938

const _ = require('lodash');

const path = require('node:path');

const glob = require('glob');

const archiver = require('archiver');

const semver = require('semver');

const fs = require('node:fs');

const { promisify } = require('node:util');

const { getAllNodeFunctions, isProviderGoogle } = require('./utils');

const readFileAsync = promisify(fs.readFile);

const statAsync = promisify(fs.stat);

function setArtifactPath(funcName, func, artifactPath) {

  const version = this.serverless.getVersion();

  if (this.log) {

    this.log.verbose(`Setting artifact for function '${funcName}' to '${artifactPath}'`);

  } else {

    this.options.verbose && this.serverless.cli.log(`Setting artifact for function '${funcName}' to '${artifactPath}'`);

  }

  // Serverless changed the artifact path location in version 1.18

  if (semver.lt(version, '1.18.0')) {

    func.artifact = artifactPath;

    func.package = _.assign({}, func.package, { disable: true });

    if (!this.log) {

      this.serverless.cli.log(`${funcName} is packaged by the webpack plugin. Ignore messages from SLS.`);

    }

  } else {

    func.package = {

      artifact: artifactPath

    };

  }

}

/**

 * Copy pasted from Serverless

 *

 * @see https://github.com/serverless/serverless/blob/63d54e1537e10ae63c171892edd886f6b81e83f6/lib/plugins/package/lib/zipService.js#L65

 */

function serverlessZip(args) {

  const { artifactFilePath, directory, files } = args;

  const zip = archiver.create('zip');

  const output = fs.createWriteStream(artifactFilePath);

  return new Promise((resolve, reject) => {

    output.on('close', () => resolve(artifactFilePath));

    output.on('error', reject);

    zip.on('error', reject);

    output.on('open', async () => {

      try {

        zip.pipe(output);

        // normalize both maps to avoid problems with e.g. Path Separators in different shells

        const normalizedFiles = _.uniq(_.map(files, file => path.normalize(file)));

        const contents = await Promise.all(

          _.map(normalizedFiles, file => getFileContentAndStat.call(this, directory, file))

        );

        _.forEach(

          contents.sort((content1, content2) => content1.filePath.localeCompare(content2.filePath)),

          file => {

            const name = file.filePath;

            // Ensure file is executable if it is locally executable or

            // we force it to be executable if platform is windows

            zip.append(file.data, {

              name,

              mode,

              // necessary to get the same hash when zipping the same content

              // as well as `contents.sort` few lines above

              date: new Date(0)

            });

          }

        );

        zip.finalize();

      } catch (error) {

        reject(error);

      }

    });

  });

}

/**

 * Copy pasted from Serverless

 *

 * @see https://github.com/serverless/serverless/blob/63d54e1537e10ae63c171892edd886f6b81e83f6/lib/plugins/package/lib/zipService.js#L112

 */

async function getFileContentAndStat(directory, filePath) {

  const fullPath = `${directory}/${filePath}`;

  try {

    const [data, stat] = await Promise.all([

      // Get file contents and stat in parallel

      readFileAsync(fullPath),

      statAsync(fullPath)

    ]);

    return {

      data,

      stat,

      filePath

    };

}

async function zip(directory, zipFileName) {

  // Check that files exist to be zipped

  let files = glob.sync('**', {

    cwd: directory,

    dot: true,

    silent: true,

    follow: true,

    nodir: true

  });

  // if excludeRegex option is defined, we'll have to list all files to be zipped

  // and then force the node way to zip to avoid hitting the arguments limit (ie: E2BIG)

  // when using the native way (ie: the zip command)

  if (this.configuration.excludeRegex) {

    const existingFilesLength = files.length;

    files = _.filter(files, f => f.match(this.configuration.excludeRegex) === null);

    } else {

      this.options.verbose &&

        this.serverless.cli.log(`Excluded ${existingFilesLength - files.length} file(s) based on excludeRegex`);

    }

  }

  if (_.isEmpty(files)) {

    throw new this.serverless.classes.Error('Packaging: No files found');

  }

  // Create artifact in temp path and move it to the package path (if any) later

  // This allows us to persist the webpackOutputPath and re-use the compiled output

  const artifactFilePath = path.join(this.webpackOutputPath, zipFileName);

  this.serverless.utils.writeFileDir(artifactFilePath);

  return serverlessZip.call(this, {

    directory,

    artifactFilePath,

    files

  });

}

function getArtifactLocations(name) {

  const archiveName = `${name}.zip`;

  const webpackArtifact = path.join(this.webpackOutputPath, archiveName);

  const serverlessArtifact = path.join('.serverless', archiveName);

  return { webpackArtifact, serverlessArtifact };

}

function copyArtifactByName(artifactName) {

  const { webpackArtifact, serverlessArtifact } = getArtifactLocations.call(this, artifactName);

  // Make sure the destination dir exists

  this.serverless.utils.writeFileDir(serverlessArtifact);

  fs.copyFileSync(webpackArtifact, serverlessArtifact);

}

function setServiceArtifactPath(artifactPath) {

  _.set(this.serverless, 'service.package.artifact', artifactPath);

}

function isIndividualPackaging() {

  return _.get(this.serverless, 'service.package.individually');

}

function getArtifactName(entryFunction) {

  return `${entryFunction.funcName || this.serverless.service.getServiceObject().name}.zip`;

}

module.exports = {

  async packageModules() {

    if (this.skipCompile) {

      return;

    }

    if (this.log) {

      this.log.verbose('[Webpack] Packaging modules');

      this.progress.get('webpack').notice('[Webpack] Packaging modules');

    }

    const stats = this.compileStats;

    const zippedArtifacts = [];

    for (const [index, compileStats] of stats.stats.entries()) {

      const entryFunction = _.get(this.entryFunctions, index, {});

      const filename = getArtifactName.call(this, entryFunction);

      const modulePath = compileStats.outputPath;

      const startZip = _.now();

      const artifactPath = await zip.call(this, modulePath, filename);

      zippedArtifacts.push(artifactPath);

      if (this.log) {

        this.log.verbose(

        );

      } else {

        this.options.verbose &&

          this.serverless.cli.log(

            `Zip ${_.isEmpty(entryFunction) ? 'service' : 'function'}: ${modulePath} [${_.now() - startZip} ms]`

          );

      }

    }

    return zippedArtifacts;

  },

  async copyExistingArtifacts() {

    if (this.log) {

      this.log.verbose('[Webpack] Copying existing artifacts');

      this.progress.get('webpack').notice('[Webpack] Copying existing artifacts');

    } else {

      this.serverless.cli.log('Copying existing artifacts...');

    }

    // When invoked as a part of `deploy function`,

    // only function passed with `-f` flag should be processed.

    const functionNames = this.options.function ? [this.options.function] : getAllNodeFunctions.call(this);

    const serviceName = this.serverless.service.getServiceObject().name;

    const individualPackagingEnabled = isIndividualPackaging.call(this);

    const providerIsGoogle = isProviderGoogle(this.serverless);

    // Copy artifacts to package location

    if (individualPackagingEnabled) {

      _.forEach(functionNames, funcName => copyArtifactByName.call(this, funcName));

    } else {

      // Copy service packaged artifact

      copyArtifactByName.call(this, serviceName);

    }

    // Loop through every function and make sure that the correct artifact is assigned

    // (the one built by webpack)

    _.forEach(functionNames, funcName => {

      const func = this.serverless.service.getFunction(funcName);

      // When individual packaging is enabled, each functions gets it's own

      // artifact, otherwise every function gets set to the same artifact

      const archiveName = individualPackagingEnabled ? funcName : serviceName;

      const { serverlessArtifact } = getArtifactLocations.call(this, archiveName);

      setArtifactPath.call(this, funcName, func, serverlessArtifact);

    });

    // If we are deploying to 'google' we need to set an artifact for the whole service,

    // rather than for each function, so there is special case here

    if (!individualPackagingEnabled && providerIsGoogle) {

      const archiveName = serviceName;

      // This may look similar to the loop above, but note that this calls

      // setServiceArtifactPath rather than setArtifactPath

      const { serverlessArtifact } = getArtifactLocations.call(this, archiveName);

      setServiceArtifactPath.call(this, serverlessArtifact);

    }

  }

};