@nizza/devkit 0.1.0-alpha.2 → 0.1.0-alpha.3

package/dist/cjs/vite/config-builder/shared/utils/helpers.js

@@ -0,0 +1,124 @@
+'use strict';
+
+var devkit = require('@nx/devkit');
+var nanoid = require('nanoid');
+var path = require('path');
+var R = require('ramda');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
+
+/**
+ * Generates a short ID string.
+ *
+ * @param {number} length - The length of the ID to generate.
+ * @returns {string} - The generated ID.
+ *
+ * @example
+ * const id = shortId(10);  // Outputs: "Aj3_Dk7_2j"
+ */ const shortId = (length)=>nanoid.nanoid(length);
+/**
+ * Deeply merges two objects, combining their properties.
+ *
+ * @param {Record<string, any>} v1 - The first object.
+ * @param {Record<string, any>} v2 - The second object.
+ * @returns {Record<string, any>} - The merged object.
+ *
+ * @example
+ * const obj1 = { a: 1, b: { c: 2 } };
+ * const obj2 = { b: { d: 3 } };
+ * const merged = deepMerge(obj1, obj2);  // Outputs: { a: 1, b: { c: 2, d: 3 } }
+ */ function deepMerge(v1, v2) {
+    if (Array.isArray(v1) && Array.isArray(v2)) {
+        return R__namespace.uniq(R__namespace.concat(v1, v2));
+    } else if (typeof v1 === 'object' && typeof v2 === 'object' && !R__namespace.isNil(v1) && !R__namespace.isNil(v2)) {
+        return R__namespace.mergeWith(deepMerge, v1, v2);
+    } else {
+        return v2;
+    }
+}
+/**
+ * Generates a name for js files.
+ *
+ * @param {string} [prefix] - An optional prefix for the chunk name.
+ * @returns - A function that takes an item and generates a chunk name.
+ *
+ * @example
+ * const generateChunkName = chunkName('prefix');
+ * const name = generateChunkName({ name: 'example' });  // Outputs: "prefix-example-Aj3_Dk7_2j.js"
+ */ const chunkName = (prefix)=>(x)=>{
+        const nameWithoutUnderscore = x.name.replace(/_/g, '');
+        const pre = prefix ? `${prefix}-` : '';
+        return `${pre}${nameWithoutUnderscore}-${shortId(8)}.js`;
+    };
+/**
+ * Returns the given object if the condition is true, otherwise returns null.
+ *
+ * @param {any} condition - The condition to evaluate.
+ * @param {Record<string, any>} obj - The object to return if the condition is true.
+ * @returns {Record<string, any> | null} - The object or null based on the condition.
+ *
+ * @example
+ * const obj = { a: 1 };
+ * const result = when(true, obj);  // Outputs: { a: 1 }
+ * const result2 = when(false, obj);  // Outputs: {}
+ */ const when = (condition, obj)=>condition ? obj : {};
+/**
+ * Filters and generates plugin configurations based on conditions and the provided context.
+ *
+ * @param {Context} ctx - The main configuration object.
+ * @returns {any[]} - An array of generated plugin configurations.
+ */ const getPlugins = (ctx, ...pluginConfigs)=>pluginConfigs // Filters the plugins based on conditions
+    .filter((p)=>!p.condition || p.condition(ctx)) // Generates the configuration of each plugin and flattens the resulting array
+    .flatMap((p)=>p.generate(ctx));
+/**
+ * Gets the paths to the tsconfig files for all relevant projects.
+ *
+ * @returns {string[]} - An array containing paths to tsconfig files for both app and lib projects.
+ *
+ * @example
+ * const projects = {
+ *   'my-app': {
+ *     type: 'app',
+ *     data: { root: 'apps/my-app' }
+ *   },
+ *   'my-lib': {
+ *     type: 'lib',
+ *     data: { root: 'libs/my-lib' }
+ *   }
+ * };
+ *
+ * const tsConfigPaths = getTsConfigPaths(projects);
+ * console.log(tsConfigPaths);
+ * // Output:
+ * // ['apps/my-app/tsconfig.app.json', 'libs/my-lib/tsconfig.lib.json']
+ */ const getNxTsConfigPaths = ()=>{
+    const isValid = (p)=>p.data.root.startsWith('apps/') || p.data.root.startsWith('libs/');
+    const getTsConfigPath = (p)=>path.resolve(p.data.root, `tsconfig.${p.type === 'app' ? 'app' : 'lib'}.json`);
+    const graph = devkit.readCachedProjectGraph();
+    const projects = graph.nodes;
+    return Object.values(projects).filter(isValid).map(getTsConfigPath);
+};
+
+exports.chunkName = chunkName;
+exports.deepMerge = deepMerge;
+exports.getNxTsConfigPaths = getNxTsConfigPaths;
+exports.getPlugins = getPlugins;
+exports.shortId = shortId;
+exports.when = when;

package/dist/{src → cjs}/vite/config-builder/shared/utils/projectConfig.d.ts

@@ -1,5 +1,5 @@
-import { type UserConfig } from 'vite';
-import { type CommonProjectConfig, type ProjectConfig, type ProjectConfigInitialized } from '../types';
+import { UserConfig } from 'vite';
+import { CommonProjectConfig, ProjectConfig, ProjectConfigInitialized } from "../types.js";
 /**
  * Initializes the project configuration with default values.
  *
@@ -7,8 +7,8 @@ import { type CommonProjectConfig, type ProjectConfig, type ProjectConfigInitial
  * const config = { type: ProjectType.APP, path: '/path/to/project', viteEnv: { mode: ViteMode.DEV } };
  * const initializedConfig = initializeConfig(config);
  */
-export declare const initializeConfig: (ccfg: CommonProjectConfig, pcfg: ProjectConfig, localPkgJson: Record<string, any>) => {
-    viteCmd: import("../types").ViteCommand;
+declare const initializeConfig: (ccfg: CommonProjectConfig, pcfg: ProjectConfig, localPkgJson: Record<string, any>) => {
+    viteCmd: import("../types.js").ViteCommand;
     cfg: ProjectConfigInitialized;
 };
 /**
@@ -18,7 +18,7 @@ export declare const initializeConfig: (ccfg: CommonProjectConfig, pcfg: Project
  * @param {UserConfig} overrides - The overrides configuration.
  * @returns {UserConfig} - The merged configuration.
  */
-export declare const mergeConfigs: (defaultConfig: UserConfig, overrides: UserConfig) => UserConfig;
+declare const mergeConfigs: (defaultConfig: UserConfig, overrides: UserConfig) => UserConfig;
 /**
  * Resolves glob patterns to actual package names found in package.json dependencies.
  * This function is used to determine which packages should be treated as external
@@ -36,7 +36,7 @@ export declare const mergeConfigs: (defaultConfig: UserConfig, overrides: UserCo
  * console.log(externalDependencies);
  * // Output might be: ['my-lib/utils', 'my-lib/core', 'lodash']
  */
-export declare const getExternalDependencies: (path: string, globs?: string | string[]) => string[];
+declare const getExternalDependencies: (path: string, globs?: string | string[]) => string[];
 /**
  * Generates a string of initials based on the input string,
  * following certain rules:
@@ -56,5 +56,5 @@ export declare const getExternalDependencies: (path: string, globs?: string | st
  * getInitials("ssv-admin"); // returns "sa"
  * getInitials("@nizza/customize-live"); // returns "cl"
  */
-export declare function getInitials(input: string): string;
-//# sourceMappingURL=projectConfig.d.ts.map
+declare function getInitials(input: string): string;
+export { initializeConfig, mergeConfigs, getExternalDependencies, getInitials };

package/dist/cjs/vite/config-builder/shared/utils/projectConfig.js

@@ -0,0 +1,114 @@
+'use strict';
+
+var minimatch = require('minimatch');
+var logger = require('../../../../shared/logger.js');
+var utils = require('../../../../shared/utils.js');
+var types = require('../types.js');
+var helpers = require('./helpers.js');
+var viteCommand = require('./viteCommand.js');
+
+/**
+ * Initializes the project configuration with default values.
+ *
+ * @example
+ * const config = { type: ProjectType.APP, path: '/path/to/project', viteEnv: { mode: ViteMode.DEV } };
+ * const initializedConfig = initializeConfig(config);
+ */ const initializeConfig = (ccfg, pcfg, localPkgJson)=>{
+    const { envPrefix } = ccfg;
+    const localPkgName = localPkgJson['name'];
+    const { name = localPkgName, overrides = {}, shadowDom = false, chunkPrefix = getInitials(localPkgName), resolveEnvs = {
+        default: true,
+        local: true
+    }, fileName = `${envPrefix}-${chunkPrefix}-index`, externalizeLibs = {
+        default: true,
+        glob: []
+    } } = pcfg;
+    const viteCmd = viteCommand.getViteCommand(pcfg.viteEnv.mode);
+    const isVerbose = Object.keys(viteCmd.flags).some((x)=>[
+            types.Flag.VERBOSE,
+            types.Flag.VERBOSE_ALIAS
+        ].includes(x));
+    const logLevel = isVerbose ? logger.LogLevel.DEBUG : pcfg.logLevel ?? logger.LogLevel.INFO;
+    logger.setLogLevel(logLevel);
+    return {
+        viteCmd,
+        cfg: {
+            ...pcfg,
+            name,
+            fileName,
+            logLevel,
+            overrides,
+            chunkPrefix,
+            shadowDom,
+            resolveEnvs,
+            externalizeLibs: externalizeLibs
+        }
+    };
+};
+/**
+ * Handles merging configurations and logs any errors.
+ *
+ * @param {UserConfig} defaultConfig - The default configuration.
+ * @param {UserConfig} overrides - The overrides configuration.
+ * @returns {UserConfig} - The merged configuration.
+ */ const mergeConfigs = (defaultConfig, overrides)=>{
+    try {
+        return helpers.deepMerge(defaultConfig, overrides);
+    } catch (err) {
+        logger.logger.error('Error merging vite configs: ', err);
+        return defaultConfig;
+    }
+};
+/**
+ * Resolves glob patterns to actual package names found in package.json dependencies.
+ * This function is used to determine which packages should be treated as external
+ * in a Rollup or Vite build configuration.
+ *
+ * @param {string} path - The base path where package.json is located.
+ * @param {string | string[]} globs - A glob pattern or an array of glob patterns to match dependencies against.
+ * @returns {string[]} An array of package names that match the given glob patterns.
+ *
+ * @example
+ * // Example of using `getExternalDependencies` to find all dependencies starting with "my-lib" and "lodash"
+ * const projectPath = '/path/to/project';
+ * const globs = ['my-lib*', 'lodash'];
+ * const externalDependencies = getExternalDependencies(projectPath, globs);
+ * console.log(externalDependencies);
+ * // Output might be: ['my-lib/utils', 'my-lib/core', 'lodash']
+ */ const getExternalDependencies = (path, globs = [])=>{
+    const pkgJson = utils.getPkgJson(path); // Assumes getLocalPkgJson is a function that reads and parses package.json
+    const dependencies = Object.keys(pkgJson.dependencies || {});
+    const globPatterns = Array.isArray(globs) ? globs : [
+        globs
+    ];
+    return dependencies.filter((dep)=>globPatterns.some((pattern)=>minimatch.minimatch(dep, pattern)));
+};
+/**
+ * Generates a string of initials based on the input string,
+ * following certain rules:
+ * 1. A word is considered as a sequence of characters
+ * separated by hyphens.
+ * 2. If the string contains '@', any characters before
+ * and including the next '/' are ignored.
+ * 3. The first character of each word is taken to form
+ * the initials.
+ *
+ * @param {string} input - The input string from which to generate the initials.
+ * @returns {string} The initials formed by taking the first character
+ * of each word, after applying the specified rules.
+ *
+ * @example
+ * getInitials("player-script"); // returns "ps"
+ * getInitials("ssv-admin"); // returns "sa"
+ * getInitials("@nizza/customize-live"); // returns "cl"
+ */ function getInitials(input) {
+    const cleanedInput = input.includes('@') ? input.split('/')[1] : input;
+    const words = cleanedInput?.split('-');
+    const initials = words?.map((word)=>word.charAt(0)).join('');
+    return initials ?? '';
+}
+
+exports.getExternalDependencies = getExternalDependencies;
+exports.getInitials = getInitials;
+exports.initializeConfig = initializeConfig;
+exports.mergeConfigs = mergeConfigs;

package/dist/{src → cjs}/vite/config-builder/shared/utils/viteCommand.d.ts

@@ -1,4 +1,4 @@
-import { ViteMode, type ViteCommand } from '../types';
+import { ViteMode, ViteCommand } from "../types.js";
 /**
  * Retrieves the Vite command details.
  *
@@ -9,7 +9,7 @@ import { ViteMode, type ViteCommand } from '../types';
  * const command = getViteCommand(ViteMode.PROD);
  * // Outputs: { stage: Stage.PROD, target: 'build', flags: {} }
  */
-export declare function getViteCommand(mode: ViteMode): ViteCommand;
+declare function getViteCommand(mode: ViteMode): ViteCommand;
 /**
  * Parses the command string to extract flags.
  *
@@ -20,5 +20,5 @@ export declare function getViteCommand(mode: ViteMode): ViteCommand;
  * const flags = getViteCmdFlags('nx run core:build --source-maps');
  * // Outputs: { 'source-maps: 'true' }
  */
-export declare function getViteCmdFlags(commandString: string | undefined): Record<string, string>;
-//# sourceMappingURL=viteCommand.d.ts.map
+declare function getViteCmdFlags(commandString: string | undefined): Record<string, string>;
+export { getViteCommand, getViteCmdFlags };

package/dist/cjs/vite/config-builder/shared/utils/viteCommand.js

@@ -0,0 +1,59 @@
+'use strict';
+
+var chalk = require('chalk');
+var argv = require('mri');
+var vite = require('vite');
+var types = require('../types.js');
+
+/**
+ * Retrieves the Vite command details.
+ *
+ * @param {ViteMode} mode - The Vite mode.
+ * @returns {ViteCommand} - The command details.
+ *
+ * @example
+ * const command = getViteCommand(ViteMode.PROD);
+ * // Outputs: { stage: Stage.PROD, target: 'build', flags: {} }
+ */ function getViteCommand(mode) {
+    const nxEnv = vite.loadEnv(mode, process.cwd(), 'NX');
+    const nxCommandString = process?.env?.['npm_package_scripts_nx'];
+    const modeIsProd = mode === types.ViteMode.PROD;
+    const stage = (nxEnv?.['NX_TASK_TARGET_CONFIGURATION']) ?? (modeIsProd ? types.Stage.PROD : types.Stage.DEV);
+    const target = nxEnv?.['NX_TASK_TARGET_TARGET'] ?? types.Target.BUILD;
+    const flags = getViteCmdFlags(nxCommandString);
+    const showIn = {
+        prod: (...args)=>modeIsProd && console.log(...args),
+        dev: (...args)=>!modeIsProd && console.log(...args)
+    };
+    try {
+        showIn.prod(chalk.cyan('Build Stage:'), chalk.green(stage));
+        showIn.dev(chalk.green('  ➜ '), chalk.bold.white(`Stage:  `), chalk.cyan(stage));
+    } catch  {
+        showIn.prod(console.log('Build Stage:', stage));
+        showIn.dev(console.log(`  ➜  Stage:  `, stage));
+    }
+    return {
+        stage,
+        target,
+        flags
+    };
+}
+/**
+ * Parses the command string to extract flags.
+ *
+ * @param {string | undefined} commandString - The command string.
+ * @returns {Record<string, string>} - The flags extracted from the command string.
+ *
+ * @example
+ * const flags = getViteCmdFlags('nx run core:build --source-maps');
+ * // Outputs: { 'source-maps: 'true' }
+ */ function getViteCmdFlags(commandString) {
+    if (!commandString) return {};
+    const cleanedCommandString = commandString.replace(/"/g, '');
+    const args = argv(cleanedCommandString.split(' '));
+    delete args['_'];
+    return args;
+}
+
+exports.getViteCmdFlags = getViteCmdFlags;
+exports.getViteCommand = getViteCommand;

package/dist/cjs/vite/plugins/shadow-dom-inject-css/index.d.ts

@@ -0,0 +1,7 @@
+import { ViteDevServer } from 'vite';
+declare function injectCssIntoShadowDom(): {
+    name: string;
+    configureServer(_server: ViteDevServer): void;
+    transform(src: string, id: string): void;
+};
+export { injectCssIntoShadowDom };

package/dist/{src → cjs}/vite/plugins/shadow-dom-inject-css/index.js

@@ -1,21 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    default: function() {
-        return _default;
-    },
-    injectCssIntoShadowDom: function() {
-        return injectCssIntoShadowDom;
-    }
-});
+'use strict';
+
 function injectCssIntoShadowDom() {
     const fileRegex = /\.(css)$/;
     let server;
@@ -41,4 +25,5 @@ function injectCssIntoShadowDom() {
         }
     };
 }
-const _default = injectCssIntoShadowDom;
+
+exports.injectCssIntoShadowDom = injectCssIntoShadowDom;

package/dist/cjs/vite/plugins/third-party-css-inject/main.d.ts

@@ -0,0 +1,17 @@
+import { Plugin } from 'vite';
+interface Execute {
+    function: (data?: string) => void;
+    listen: string;
+    observer: string;
+}
+interface ThirdPartyCssInjectPlugin {
+    topExecutionPriority?: boolean;
+    execute?: Execute[];
+}
+/**
+ * Inject the CSS compiled with JS.
+ *
+ * @return {Plugin}
+ */
+declare function thirdPartyCssInjectPlugin({ topExecutionPriority, execute }?: ThirdPartyCssInjectPlugin | undefined): Plugin;
+export { Execute, ThirdPartyCssInjectPlugin, thirdPartyCssInjectPlugin };

package/dist/{src → cjs}/vite/plugins/third-party-css-inject/main.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "thirdPartyCssInjectPlugin", {
-    enumerable: true,
-    get: function() {
-        return thirdPartyCssInjectPlugin;
-    }
-});
-const _utils = require("./utils");
-function thirdPartyCssInjectPlugin({ topExecutionPriority, execute } = {
+'use strict';
+
+var utils = require('./utils.js');
+
+/**
+ * Inject the CSS compiled with JS.
+ *
+ * @return {Plugin}
+ */ function thirdPartyCssInjectPlugin({ topExecutionPriority, execute } = {
     topExecutionPriority: true,
     execute: []
 }) {
@@ -33,12 +30,12 @@ function thirdPartyCssInjectPlugin({ topExecutionPriority, execute } = {
                 const htmlChunk = bundle[name];
                 let replacedHtml = htmlChunk.source;
                 cssAssets.forEach((cssName)=>{
-                    replacedHtml = (0, _utils.removeLinkStyleSheets)(replacedHtml, cssName);
+                    replacedHtml = utils.removeLinkStyleSheets(replacedHtml, cssName);
                     htmlChunk.source = replacedHtml;
                 });
             }
             const jsAsset = bundle[jsAssets[0]];
-            const cssInjectionCode = await (0, _utils.buildCSSInjectionCode)(execute);
+            const cssInjectionCode = await utils.buildCSSInjectionCode(execute);
             const appCode = jsAsset.code;
             jsAsset.code = topExecutionPriority ? '' : appCode;
             jsAsset.code += cssInjectionCode ? cssInjectionCode.code : '';
@@ -46,3 +43,5 @@ function thirdPartyCssInjectPlugin({ topExecutionPriority, execute } = {
         }
     };
 }
+
+exports.thirdPartyCssInjectPlugin = thirdPartyCssInjectPlugin;

package/dist/cjs/vite/plugins/third-party-css-inject/utils.d.ts

@@ -0,0 +1,5 @@
+import { OutputChunk } from 'rollup';
+import { Execute } from "../../../index-3080371d.js";
+declare function buildCSSInjectionCode(execute?: Execute[]): Promise<OutputChunk | null | any>;
+declare function removeLinkStyleSheets(html: string, cssFileName: string): string;
+export { buildCSSInjectionCode, removeLinkStyleSheets };

package/dist/{src → cjs}/vite/plugins/third-party-css-inject/utils.js

@@ -1,22 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    buildCSSInjectionCode: function() {
-        return buildCSSInjectionCode;
-    },
-    removeLinkStyleSheets: function() {
-        return removeLinkStyleSheets;
-    }
-});
-const _vite = require("vite");
+'use strict';
+
+var vite = require('vite');
+
 const cssInjectedByJsId = '\0vite/all-css';
 const waitForElement = (selector, observerElementName = 'body')=>{
     const getElement = (selector)=>document.querySelector(selector);
@@ -47,7 +32,7 @@ const waitForElement = (selector, observerElementName = 'body')=>{
     });
 };
 async function buildCSSInjectionCode(execute) {
-    const res = await (0, _vite.build)({
+    const res = await vite.build({
         root: '',
         configFile: false,
         logLevel: 'error',
@@ -110,3 +95,6 @@ function removeLinkStyleSheets(html, cssFileName) {
     const removeCSS = new RegExp(`<link rel=".*"[^>]*?href=".*/?${cssFileName}"[^>]*?>`);
     return html.replace(removeCSS, '');
 }
+
+exports.buildCSSInjectionCode = buildCSSInjectionCode;
+exports.removeLinkStyleSheets = removeLinkStyleSheets;

package/dist/esm/executors/deploy/helpers.d.ts

@@ -0,0 +1,4 @@
+declare function cleanS3Bucket(s3BucketPath: string): Promise<void>;
+declare function copyAssetsToS3(s3BucketPath: string, projectRoot: string): Promise<void>;
+declare function createCloudFrontInvalidation(distributionId: string, invalidationPaths: string[]): Promise<void>;
+export { cleanS3Bucket, copyAssetsToS3, createCloudFrontInvalidation };

package/dist/esm/executors/deploy/helpers.js

@@ -0,0 +1,22 @@
+import { logger } from '@nx/devkit';
+import { runCommand } from '../shared/utils.js';
+
+async function cleanS3Bucket(s3BucketPath) {
+    logger.info('🧹 Cleaning S3 bucket...');
+    await runCommand(`aws s3 rm ${s3BucketPath} --recursive`);
+    logger.info('✅ S3 bucket cleared.');
+}
+async function copyAssetsToS3(s3BucketPath, projectRoot) {
+    logger.info('📦 Copying assets to S3 bucket...');
+    await runCommand(`aws s3 cp ${projectRoot}/dist ${s3BucketPath} --recursive`);
+    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}`;
+    logger.info('🔃 Creating invalidation for CloudFront...');
+    await runCommand(command);
+    logger.info('🔄 CloudFront invalidation created.');
+}
+
+export { cleanS3Bucket, copyAssetsToS3, createCloudFrontInvalidation };

package/dist/esm/executors/deploy/index.d.ts

@@ -0,0 +1,11 @@
+import { ExecutorContext } from '@nx/devkit';
+import { ExecutorResponse } from "../../index-f6330edc.js";
+interface ExecutorOptions {
+    s3BucketPath: string;
+    cloudFrontDistributionId: string;
+    cloudFrontInvalidationPaths: string[];
+    buildTarget: string;
+    skipBuild?: boolean;
+}
+declare function deployExecutor(opts: ExecutorOptions, ctx: ExecutorContext): Promise<ExecutorResponse>;
+export { ExecutorOptions, deployExecutor as default };

package/dist/esm/executors/deploy/index.js

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

package/dist/esm/executors/deploy/schema.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "version": 2,
+  "title": "Deploy executor",
+  "description": "",
+  "type": "object",
+  "properties": {
+    "s3BucketPath": {
+      "type": "string",
+      "description": "S3 BUCKET ROUTE"
+    },
+    "cloudFrontDistributionId": {
+      "type": "string",
+      "description": "Cloudfront distribution id for cache invalidation"
+    },
+    "cloudFrontInvalidationPaths": {
+      "type": "array",
+      "description": "Cloudfront path list that must be invalidated in the cache",
+      "items": {
+        "type": "string"
+      },
+      "uniqueItems": true,
+      "minItems": 1
+    },
+    "buildTarget": {
+      "type": "string",
+      "description": "Build command relative to the project and without the name of the project because it is not necessary"
+    },
+    "skipBuild": {
+      "type": "boolean",
+      "description": "It allows to omit the Build process and assumes that it was already done",
+      "default": false
+    }
+  },
+  "required": [
+    "s3BucketPath",
+    "cloudFrontDistributionId",
+    "cloudFrontInvalidationPaths",
+    "buildTarget"
+  ]
+}

package/dist/esm/executors/environments/helpers.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Creates the content for an environment file based on the core environment path.
+ *
+ * @param {string} coreEnvPath - The path to the core environment file.
+ * @returns {string} The content of the environment file.
+ */
+declare function createEnvironmentFileContent(coreEnvPath: string): Promise<string>;
+/**
+ * Ensures that the given directory exists, creating it if it does not.
+ *
+ * @param {string} dir - The path to the directory to check/create.
+ */
+declare function ensureDirectoryExists(dir: string): Promise<void>;
+/**
+ * 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.
+ */
+declare function writeFilesIfNotExist(basePath: string, files: Record<string, string>): Promise<void>;
+export { createEnvironmentFileContent, ensureDirectoryExists, writeFilesIfNotExist };