@nizza/devkit 0.1.0-alpha.1 → 0.1.0-alpha.11

package/dist/cjs/executors/deploy/helpers.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var devkit = require('@nx/devkit');
+var utils = require('../shared/utils.cjs');
+
+async function cleanS3Bucket(s3BucketPath) {
+    devkit.logger.info('🧹 Cleaning S3 bucket...');
+    await utils.runCommand(`aws s3 rm ${s3BucketPath} --recursive`);
+    devkit.logger.info('✅ S3 bucket cleared.');
+}
+async function copyAssetsToS3(s3BucketPath, projectRoot) {
+    devkit.logger.info('📦 Copying assets to S3 bucket...');
+    await utils.runCommand(`aws s3 cp ${projectRoot}/dist ${s3BucketPath} --recursive`);
+    devkit.logger.info('🚚 Assets files copied.');
+}
+async function createCloudFrontInvalidation(distributionId, invalidationPaths) {
+    const pathsString = invalidationPaths.map((path)=>`"${path}"`).join(' ');
+    const command = `aws cloudfront create-invalidation --distribution-id ${distributionId} --paths ${pathsString}`;
+    devkit.logger.info('🔃 Creating invalidation for CloudFront...');
+    await utils.runCommand(command);
+    devkit.logger.info('🔄 CloudFront invalidation created.');
+}
+
+exports.cleanS3Bucket = cleanS3Bucket;
+exports.copyAssetsToS3 = copyAssetsToS3;
+exports.createCloudFrontInvalidation = createCloudFrontInvalidation;

package/dist/cjs/executors/deploy/index.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var utils = require('../shared/utils.cjs');
+var helpers = require('./helpers.cjs');
+
+async function deployExecutor(opts, ctx) {
+    try {
+        const { root, name } = utils.getProjectConfig(ctx);
+        const { s3BucketPath, cloudFrontDistributionId, cloudFrontInvalidationPaths, skipBuild = false } = opts;
+        const buildTarget = `${name}:${opts.buildTarget}`;
+        if (!skipBuild) await utils.runCommand(`nx run ${buildTarget}`);
+        await helpers.cleanS3Bucket(s3BucketPath);
+        await helpers.copyAssetsToS3(s3BucketPath, root);
+        await helpers.createCloudFrontInvalidation(cloudFrontDistributionId, cloudFrontInvalidationPaths);
+        const now = new Date().toLocaleString();
+        return utils.ok(`✨ Build completed successfully on ${now}`);
+    } catch (error) {
+        return utils.err(error, '❌ Error when executing deploy command');
+    }
+}
+
+module.exports = deployExecutor;

package/dist/cjs/executors/environments/helpers.cjs

@@ -0,0 +1,62 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var devkit = require('@nx/devkit');
+
+const { mkdir, writeFile, access } = fs.promises;
+/**
+ * Creates the content for an environment file based on the core environment path.
+ *
+ * @param {CreateEnvironmentData} data - Values to replace in template.
+ * @returns {string} The content of the environment file.
+ */ async function createEnvironmentFileContent({ coreEnvFile, projectOrg }) {
+    return `import { Environment } from '@${projectOrg}/core';
+import coreEnvs from '@${projectOrg}/core/envs/${coreEnvFile}';
+
+const config = {
+  ...coreEnvs,
+};
+
+export const environment: Environment<typeof config> = config;
+export default environment;
+`;
+}
+/**
+ * Ensures that the given directory exists, creating it if it does not.
+ *
+ * @param {string} dir - The path to the directory to check/create.
+ */ async function ensureDirectoryExists(dir) {
+    try {
+        await access(dir);
+        devkit.logger.info('✅ Directory exists.');
+    } catch  {
+        devkit.logger.info('📁 Directory does not exist. Creating...');
+        await mkdir(dir, {
+            recursive: true
+        });
+        devkit.logger.info('📁 Directory created.');
+    }
+}
+/**
+ * Writes environment files to the given base path if they do not already exist.
+ *
+ * @param {string} basePath - The base directory where the files should be written.
+ * @param {Record<string, string>} files - An object containing filenames and their respective content.
+ */ async function writeFilesIfNotExist(basePath, files) {
+    await Promise.all(Object.entries(files).map(async ([filename, content])=>{
+        const filePath = path.join(basePath, filename);
+        try {
+            await access(filePath);
+            devkit.logger.info(`✅ The file "${filename}" already exists.`);
+        } catch  {
+            devkit.logger.warn(`📝 The file "${filename}" does not exist. Creating...`);
+            await writeFile(filePath, content);
+            devkit.logger.info(`🎉 The file "${filename}" has been created.`);
+        }
+    }));
+}
+
+exports.createEnvironmentFileContent = createEnvironmentFileContent;
+exports.ensureDirectoryExists = ensureDirectoryExists;
+exports.writeFilesIfNotExist = writeFilesIfNotExist;

package/dist/cjs/executors/environments/index.cjs

@@ -0,0 +1,60 @@
+'use strict';
+
+var path = require('path');
+var utils = require('../shared/utils.cjs');
+var helpers = require('./helpers.cjs');
+require('../../shared/logger.cjs');
+var utils$1 = require('../../shared/utils.cjs');
+
+const ENV_DIR = 'src/environments';
+const ENV_DEV_FILE = 'environment.ts';
+const ENV_LOCAL_FILE = 'environment.local.ts';
+const ENV_PROD_FILE = 'environment.prod.ts';
+const ENV_STAGING_FILE = 'environment.staging.ts';
+const environmentFiles = [
+    ENV_DEV_FILE,
+    ENV_LOCAL_FILE,
+    ENV_PROD_FILE,
+    ENV_STAGING_FILE
+];
+/**
+ * The executor function to create environment files.
+ * Ensures that the directory for the environment files exists and creates the files
+ * if they do not exist already. Files created are 'environment.ts', 'environment.prod.ts',
+ * and 'environment.staging.ts'.
+ *
+ * @param {ExecutorOptions} _opts - Executor options, currently not used but provided for future extensibility.
+ * @param {ExecutorContext} ctx - The executor context, providing access to the project configuration.
+ * @returns {Promise<ExecutorResponse>} The result object with a success or error status.
+ */ async function runExecutor(_opts, ctx) {
+    try {
+        const projectConfig = utils.getProjectConfig(ctx);
+        const environmentsDir = path.join(projectConfig.root, ENV_DIR);
+        const mainPkgJson = utils$1.getPkgJson(ctx.root);
+        const getEnvPath = (fileName)=>{
+            const isLocal = fileName.includes('.local');
+            const coreEnvFile = (isLocal ? ENV_DEV_FILE : fileName).replace('.ts', '');
+            const key = isLocal ? ENV_LOCAL_FILE : fileName;
+            return {
+                key,
+                coreEnvFile
+            };
+        };
+        await helpers.ensureDirectoryExists(environmentsDir);
+        for (const envFileName of environmentFiles){
+            const { key, coreEnvFile } = getEnvPath(envFileName);
+            const content = await helpers.createEnvironmentFileContent({
+                coreEnvFile,
+                projectOrg: mainPkgJson.name
+            });
+            await helpers.writeFilesIfNotExist(environmentsDir, {
+                [key]: content
+            });
+        }
+        return utils.ok();
+    } catch (error) {
+        return utils.err(error, `Failed to create environment files:`);
+    }
+}
+
+module.exports = runExecutor;

package/dist/cjs/executors/publish/helpers.cjs

@@ -0,0 +1,51 @@
+'use strict';
+
+var devkit = require('@nx/devkit');
+var child_process = require('child_process');
+var util = require('util');
+
+const execAsync = util.promisify(child_process.exec);
+/**
+ * Retrieves the version of a published package with a given name and tag.
+ *
+ * @param {string} packageName The name of the package to retrieve the version for.
+ * @param {string} tag The tag to retrieve the version for.
+ * @returns The version of the package as a string or an object containing versions for each tag.
+ */ async function getPublishedPackageVersion(packageName, tag) {
+    const withTag = tag ? `.${tag}` : ' --json';
+    const command = `npm view ${packageName} dist-tags${withTag}`;
+    const { stdout, stderr } = await execAsync(command);
+    if (stderr) {
+        devkit.logger.error(stderr.trim());
+        process.exit(1);
+    }
+    const published = stdout.trim();
+    return tag ? published : JSON.parse(published);
+}
+/**
+ * Checks if a package with the given name is already published and returns its version.
+ *
+ * @param {string} packageName The name of the package to check for.
+ * @returns An object containing the published versions of the package and a flag indicating if it is the first version.
+ */ async function checkPublishedVersion(packageName) {
+    let publishedVersion;
+    let isFirstVersion = false;
+    try {
+        publishedVersion = await getPublishedPackageVersion(packageName);
+    } catch (err) {
+        if (err?.message.includes('code E404')) {
+            isFirstVersion = true;
+            devkit.logger.info(`🏁 This is the first version of "${packageName}" package. \n`);
+        } else {
+            devkit.logger.error('❌ Error when checking the last published versions \n');
+            throw err;
+        }
+    }
+    return {
+        publishedVersion,
+        isFirstVersion
+    };
+}
+
+exports.checkPublishedVersion = checkPublishedVersion;
+exports.getPublishedPackageVersion = getPublishedPackageVersion;

package/dist/cjs/executors/publish/index.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+var devkit = require('@nx/devkit');
+var semver = require('semver');
+require('../../shared/logger.cjs');
+var utils$1 = require('../../shared/utils.cjs');
+var utils = require('../shared/utils.cjs');
+var helpers = require('./helpers.cjs');
+
+/**
+ * This is a minimal script to publish package to "npm".
+ * Need to authenticate with NPM before running this script.
+ */ async function runExecutor(opts, ctx) {
+    try {
+        const { tag, dryRun: isDryRun } = opts;
+        const { root: projectRoot } = utils.getProjectConfig(ctx);
+        // Read the package.json file and extract the name and version.
+        const packageJson = utils$1.getPkgJson(projectRoot);
+        const { name: packageName, version: packageVersion } = packageJson;
+        // Check if the package has been previously published and get the published version.
+        const { publishedVersion, isFirstVersion } = await helpers.checkPublishedVersion(packageName);
+        let greaterThanTagVersion, greaterThanLatestVersion;
+        if (!isFirstVersion) {
+            // Check if the package version is greater than the latest published version for the specified tag.
+            greaterThanTagVersion = publishedVersion?.[tag] ? semver.gt(packageVersion, publishedVersion?.[tag]) : true;
+            // Check if the package version is greater than the latest published version.
+            greaterThanLatestVersion = semver.gt(packageVersion, publishedVersion.latest);
+            console.log(`🔎 package.json version: ${packageVersion}`);
+            console.log('🔺 published versions:');
+            Object.entries(publishedVersion).forEach(([k, v])=>console.log(`   * ${k}: ${v}`));
+            console.log('\n');
+        }
+        // Publish the package if it's the first version or if it's a new version.
+        const needsPublish = isFirstVersion || greaterThanLatestVersion && greaterThanTagVersion;
+        if (needsPublish) {
+            const dryRun = isDryRun ? '--dry-run' : '';
+            const commandToPublish = `pnpm publish --access public --tag ${tag} --no-git-checks ${dryRun}`;
+            isDryRun && devkit.logger.info('👀 Skip publish (dry run) \n');
+            devkit.logger.info(`${commandToPublish} \n`);
+            // Execute the command to publish the package.
+            // process.chdir(projectRoot);
+            await utils.runCommand(commandToPublish, projectRoot);
+            devkit.logger.info(`\n🚀 Successfully published ${packageName}@${packageVersion}`);
+        } else {
+            devkit.logger.warn(`👻 Package version "${packageVersion}" is invalid.`);
+        }
+        return utils.ok();
+    } catch (error) {
+        return utils.err(error, '❌ Error when publishing the package');
+    }
+}
+
+module.exports = runExecutor;

package/dist/cjs/executors/shared/utils.cjs

@@ -0,0 +1,67 @@
+'use strict';
+
+var devkit = require('@nx/devkit');
+var child_process = require('child_process');
+var util = require('util');
+
+const execAsync = util.promisify(child_process.exec);
+/**
+ * Indicates a successful executor operation.
+ *
+ * @param {string} message - Optional message to log for the success case.
+ * @returns {ExecutorResponse} - An object representing a successful operation.
+ */ function ok(message) {
+    message && devkit.logger.info(message);
+    return {
+        success: true
+    };
+}
+/**
+ * Indicates a failed executor operation.
+ *
+ * @param {string | Error | unknown} err - An optional error object or message indicating the nature of the failure.
+ * @param {string} message - An optional message to log for the error case. If not provided, a default error message is logged.
+ * @returns {ExecutorResponse} - An object representing a failed operation.
+ */ function err(err, message) {
+    if (message) {
+        devkit.logger.error(message);
+    } else {
+        devkit.logger.error(`❌ an error occurred:`);
+    }
+    if (err) devkit.logger.error(err);
+    return {
+        success: false
+    };
+}
+/**
+ * Retrieves the project configuration for the current execution context.
+ *
+ * @param {ExecutorContext} ctx - The execution context containing project information.
+ * @returns {ProjectConfiguration} - The configuration object for the current project.
+ * @throws {Error} If the project configuration is invalid or not found.
+ */ function getProjectConfig(ctx) {
+    const projectName = ctx.projectName || '';
+    const projectConfig = ctx.projectsConfigurations?.projects?.[projectName];
+    if (!projectConfig) throw new Error('Invalid project configuration.');
+    return projectConfig;
+}
+async function runCommand(command, cwd) {
+    try {
+        const { stdout, stderr } = await execAsync(command, {
+            ...cwd && {
+                cwd
+            }
+        });
+        devkit.logger.info(stdout);
+        devkit.logger.info(stderr);
+    } catch (error) {
+        devkit.logger.error(`Unexpected error running command:`);
+        devkit.logger.error(error);
+        throw error;
+    }
+}
+
+exports.err = err;
+exports.getProjectConfig = getProjectConfig;
+exports.ok = ok;
+exports.runCommand = runCommand;

package/dist/cjs/executors/update-executors-file/helpers.cjs

@@ -0,0 +1,64 @@
+'use strict';
+
+var devkit = require('@nx/devkit');
+var fs = require('fs');
+var R = require('ramda');
+
+const { writeFile } = fs.promises;
+const transformPathToRoot = (path)=>{
+    const distPrefix = './dist/cjs/';
+    const srcRegex = /^\.\/src\//;
+    const executorTsRegex = /executor\.ts$/;
+    const jsonFileRegex = /\.json$/;
+    const isJson = jsonFileRegex.test(path);
+    const changeSrcPath = (p)=>p.replace(srcRegex, distPrefix);
+    const changeFileName = (p)=>isJson ? p : p.replace(executorTsRegex, 'index.cjs');
+    return R.pipe(changeSrcPath, changeFileName)(path);
+};
+const transformPathToDist = (path)=>{
+    const cjsPrefix = './cjs/';
+    const distRegex = /^\.\/dist\/cjs\//;
+    return path.replace(distRegex, cjsPrefix);
+};
+/**
+ * Updates the executor paths for the provided executors object.
+ * @param {Executors} executors - The executors object from executors.json.
+ * @param {boolean} toDist - Flag to determine if './dist' should be removed from paths.
+ * @returns - The updated executors object with transformed paths.
+ */ const updateExecutorPaths = (executors, toDist)=>{
+    const transform = R.cond([
+        [
+            R.always(toDist),
+            transformPathToDist
+        ],
+        [
+            R.T,
+            transformPathToRoot
+        ]
+    ]);
+    return Object.entries(executors).reduce((updatedExecutors, [key, executor])=>{
+        updatedExecutors[key] = {
+            ...executor,
+            implementation: transform(executor.implementation),
+            schema: transform(executor.schema)
+        };
+        return updatedExecutors;
+    }, {});
+};
+/**
+ * Writes a JSON file asynchronously.
+ * @param {string} path - The file path where to write the JSON data.
+ * @param {any} data - The data to be written to the file.
+ */ const writeJsonFileAsync = async (path, data)=>{
+    try {
+        await writeFile(path, JSON.stringify(data, null, 2));
+        devkit.logger.info(`✅ Updated: ${path}`);
+    } catch (error) {
+        devkit.logger.error(`❌ Error writing file ${path}: ${error}`);
+    }
+};
+
+exports.transformPathToDist = transformPathToDist;
+exports.transformPathToRoot = transformPathToRoot;
+exports.updateExecutorPaths = updateExecutorPaths;
+exports.writeJsonFileAsync = writeJsonFileAsync;

package/dist/cjs/executors/update-executors-file/index.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var utils = require('../shared/utils.cjs');
+var helpers = require('./helpers.cjs');
+
+const { readFile } = fs.promises;
+/**
+ * Executor function to update paths in the executors.json file.
+ *
+ * @param {ExecutorOptions} _opts - Executor options, currently not used but provided for future extensibility.
+ * @param {ExecutorContext} ctx - The executor context, providing access to the project configuration.
+ * @returns {Promise<ExecutorResponse>} The result object with a success or error status.
+ */ async function runExecutor(_opts, ctx) {
+    try {
+        const projectConfig = utils.getProjectConfig(ctx);
+        const rootDir = projectConfig.root;
+        const executorsFilePath = path.join(rootDir, 'executors.json');
+        const distExecutorsFilePath = path.join(rootDir, 'dist', 'executors.json');
+        const originalContent = JSON.parse(await readFile(executorsFilePath, 'utf8'));
+        // Update paths to point to './dist/' and add '.js'
+        const updatedExecutors = helpers.updateExecutorPaths(originalContent.executors, false);
+        // Prepare the version for the dist folder by removing './dist/' from paths
+        // const distExecutors = updateExecutorPaths(updatedExecutors, true);
+        // Write both files asynchronously and in parallel
+        await Promise.all([
+            helpers.writeJsonFileAsync(executorsFilePath, {
+                executors: updatedExecutors
+            })
+        ]);
+        return utils.ok(`🚀 Executors updated successfully.`);
+    } catch (error) {
+        return utils.err(error, `❌ Error processing file: ${error}`);
+    }
+}
+
+module.exports = runExecutor;

package/dist/cjs/executors/vtex-link/constants.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+const VTEX_PROJECT_PATH = process.env.NZ_VTEX_PROJECT;
+const ERROR_LINKING_FLAG = '[31merror: App build failed';
+const SUCCESS_LINKING_FLAG = '[32minfo: App running';
+
+exports.ERROR_LINKING_FLAG = ERROR_LINKING_FLAG;
+exports.SUCCESS_LINKING_FLAG = SUCCESS_LINKING_FLAG;
+exports.VTEX_PROJECT_PATH = VTEX_PROJECT_PATH;

package/dist/cjs/executors/vtex-link/helpers.cjs

@@ -0,0 +1,206 @@
+'use strict';
+
+var devkit = require('@nx/devkit');
+var child_process = require('child_process');
+var fs = require('fs');
+var path = require('path');
+var util = require('util');
+require('../../shared/logger.cjs');
+var utils$1 = require('../../shared/utils.cjs');
+var utils = require('../shared/utils.cjs');
+var constants = require('./constants.cjs');
+
+const execAsync = util.promisify(child_process.exec);
+const getPkgJsonPath = (vtexProjectPath)=>path.resolve(vtexProjectPath, 'package.json');
+/**
+ * Links the local package to the VTEX environment.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<void>} A promise that resolves when the package is linked or rejects on error.
+ */ function vtexLink(ctx) {
+    const { vtexProjectPath } = ctx;
+    return new Promise((resolve, reject)=>{
+        devkit.logger.info('🔗 Linking package to VTEX...');
+        const link = child_process.spawn('vtex', [
+            'link',
+            '-u'
+        ], {
+            cwd: vtexProjectPath,
+            detached: true
+        });
+        link.stdout.on('data', (chunk)=>{
+            const data = chunk.toString('utf8');
+            if (data.includes(constants.ERROR_LINKING_FLAG)) {
+                reject('could not link package in VTEX');
+            }
+            if (data.includes(constants.SUCCESS_LINKING_FLAG)) {
+                link.pid && process.kill(-link.pid);
+                setTimeout(()=>{
+                    link.kill();
+                    devkit.logger.info('✅ Successfully linked package to VTEX.');
+                }, 200);
+                resolve();
+            }
+            devkit.logger.info(data);
+        });
+        link.on('error', (error)=>reject(error.message));
+    });
+}
+/**
+ * Updates the package.json file within the VTEX project to use the local version of the package.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @param {string} packageName - The name of the package to link.
+ * @returns {Promise<void>} A promise that resolves when the package.json is updated.
+ */ async function changePackageJsonFromVtexProject(ctx, packageName) {
+    const { vtexProjectPath, projectName, packageOrg } = ctx;
+    const pkgJsonPath = getPkgJsonPath(vtexProjectPath);
+    // Make backup of package.json
+    await fs.promises.copyFile(pkgJsonPath, path.join(vtexProjectPath, 'package.json.nxback'));
+    devkit.logger.info('🔃 Created package.json backup.');
+    // Find and edit value "@${packageOrg}/${projectName}" dependency
+    const packageJson = utils$1.getPkgJson(vtexProjectPath);
+    const newPackageJson = {
+        ...packageJson,
+        dependencies: {
+            ...packageJson.dependencies,
+            [`@${packageOrg}/${projectName}`]: `file:./${packageName}`
+        }
+    };
+    await fs.promises.unlink(pkgJsonPath);
+    await fs.promises.writeFile(pkgJsonPath, JSON.stringify(newPackageJson, null, 2));
+    devkit.logger.info('📝 Updated package.json in VTEX project.');
+}
+/**
+ * Restores the original package.json from the backup created before modifications.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<void>} A promise that resolves when the package.json is restored.
+ */ async function restorePackageJsonFromVtexProject(ctx) {
+    const { vtexProjectPath } = ctx;
+    const pkgJsonPath = getPkgJsonPath(vtexProjectPath);
+    const backupFile = path.resolve(vtexProjectPath, 'package.json.nxback');
+    if (!fs.existsSync(backupFile)) return;
+    await fs.promises.unlink(pkgJsonPath);
+    await fs.promises.copyFile(backupFile, pkgJsonPath);
+    await fs.promises.unlink(backupFile);
+    devkit.logger.info('🔄 Restored package.json in VTEX project.');
+}
+/**
+ * Renames the generated package file with a unique identifier.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<string>} A promise that resolves with the new name of the package.
+ */ async function renamePackage(ctx) {
+    const { projectRoot, projectName, packageOrg } = ctx;
+    const packageJson = utils$1.getPkgJson('./');
+    const oldName = `${packageOrg}-${projectName}-${packageJson.version}.tgz`;
+    const oldPath = path.join(projectRoot, oldName);
+    const newName = `${packageOrg}-${projectName}-${packageJson.version}-${utils$1.shortId(8)}.tgz`;
+    const newPath = path.join(projectRoot, newName);
+    await fs.promises.rename(oldPath, newPath);
+    devkit.logger.info(`🏷️ New package name: ${newName}`);
+    return newName;
+}
+/**
+ * Creates a pnpm package for uploading to VTEX.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<string>} A promise that resolves with the name of the created package.
+ */ async function createPackage(ctx) {
+    const command = 'pnpm pack';
+    const { stderr } = await execAsync(command);
+    if (stderr) devkit.logger.error(stderr);
+    devkit.logger.info('📦 Package generated successfully.');
+    return renamePackage(ctx);
+}
+/**
+ * Searches for and lists all outdated packages in the VTEX project directory.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<string[]>} A promise that resolves with a list of deprecated package names.
+ */ async function findLastPackages(ctx) {
+    const { vtexProjectPath, projectName, packageOrg } = ctx;
+    const matchedFiles = [];
+    const files = await fs.promises.readdir(vtexProjectPath);
+    for (const file of files){
+        const regex = new RegExp(`^${packageOrg}-${projectName}-.*$`);
+        if (regex.test(file)) {
+            matchedFiles.push(file);
+            devkit.logger.info(`🔍 Found deprecated package: ${file}`);
+        }
+    }
+    return matchedFiles;
+}
+/**
+ * Removes all outdated packages in the VTEX project directory.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<void>} A promise that resolves when the old packages are removed.
+ */ async function removeOldPackages(ctx) {
+    const { vtexProjectPath } = ctx;
+    const files = await findLastPackages(ctx);
+    const toRemove = files.map((x)=>fs.promises.unlink(path.resolve(vtexProjectPath, x)));
+    await Promise.all(toRemove);
+    devkit.logger.info('🗑️ Removed old packages in VTEX project.');
+}
+/**
+ * Moves a package to the VTEX project directory.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @param {string} packageName - The name of the package to move.
+ * @returns {Promise<void>} A promise that resolves when the package is moved successfully.
+ */ async function movePackage(ctx, packageName) {
+    const { vtexProjectPath } = ctx;
+    await fs.promises.rename(path.resolve(packageName), path.join(vtexProjectPath, packageName));
+    devkit.logger.info(`🚚 Moved package "${packageName}" to VTEX project.`);
+}
+/**
+ * Builds the package, moves it to the VTEX project, and updates the project's package.json.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<void>} A promise that resolves when the build is complete.
+ */ async function buildPackage(ctx) {
+    const packageName = await createPackage(ctx);
+    await Promise.all([
+        movePackage(ctx, packageName),
+        changePackageJsonFromVtexProject(ctx, packageName)
+    ]);
+}
+/**
+ * Cleans the VTEX project by removing old packages and restoring the original package.json.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<void>} A promise that resolves when the clean-up is complete.
+ */ async function clean(ctx) {
+    await Promise.all([
+        removeOldPackages(ctx),
+        restorePackageJsonFromVtexProject(ctx)
+    ]);
+}
+function validateEnvironment() {
+    if (!constants.VTEX_PROJECT_PATH) throw new Error('The NZ_VTEX_PROJECT environment variable is missing. Set it in the project root in a .env.local file.');
+}
+async function performRollback(sharedContext) {
+    await clean(sharedContext);
+    return utils.ok();
+}
+async function buildAndLink(sharedContext, skipLink = false) {
+    await clean(sharedContext);
+    await buildPackage(sharedContext);
+    if (!skipLink) await vtexLink(sharedContext);
+}
+
+exports.buildAndLink = buildAndLink;
+exports.buildPackage = buildPackage;
+exports.changePackageJsonFromVtexProject = changePackageJsonFromVtexProject;
+exports.clean = clean;
+exports.createPackage = createPackage;
+exports.findLastPackages = findLastPackages;
+exports.movePackage = movePackage;
+exports.performRollback = performRollback;
+exports.removeOldPackages = removeOldPackages;
+exports.renamePackage = renamePackage;
+exports.restorePackageJsonFromVtexProject = restorePackageJsonFromVtexProject;
+exports.validateEnvironment = validateEnvironment;
+exports.vtexLink = vtexLink;