@breadstone-infrastructure/nx-tasks 0.0.256 → 0.0.258

package/src/executors/release-package/executor.task.ts

@@ -0,0 +1,212 @@
+// #region Imports
+
+import { ConsoleLogger, logSeparator, logTree, magenta, red, Path, bold, File, yellow, type ILogger, gray, green } from '@breadstone-infrastructure/utilities';
+import { execSync } from 'child_process';
+import type { PackageJson, TsConfigJson } from 'type-fest';
+import * as semver from 'semver';
+
+// #endregion
+
+export namespace PublishPackageTask {
+
+    export interface IPublishPackageTaskOptions {
+        cwd: string;
+        packageJson: PackageJson;
+        tsConfigJson: TsConfigJson;
+        dryRun?: boolean;
+        verbose?: boolean;
+
+        /**
+         * The path to the output directory where the package will be published.
+         * If not specified, the default output directory from the tsconfig.json will be used.
+         */
+        outPath?: string;
+    }
+
+    interface INpmPackageInfo {
+        name: string;
+        version: string;
+        description?: string;
+        homepage?: string;
+        license?: string;
+        maintainers?: Array<{
+            name: string;
+            email?: string;
+        }>;
+        time?: Record<string, string>;
+        distTags?: Record<string, string>;
+    }
+
+    export async function run(options: IPublishPackageTaskOptions): Promise<boolean> {
+        const logger = new ConsoleLogger();
+
+        logSeparator(logger, 'Publish Package');
+
+        logger.info(`    ${magenta('Preparing package info...')}`);
+
+        const outPath = options.outPath === undefined
+            ? Path.combine(options.cwd, options.tsConfigJson.compilerOptions?.outDir ?? '')
+            : Path.combine(options.cwd, options.outPath);
+
+        const localPackageInfo = tryGetLocalPackageInfo(outPath);
+
+        if (!localPackageInfo) {
+            logger.error(red(`Package.json not found at ${outPath}`));
+            return false;
+        }
+
+        if (localPackageInfo.version === undefined) {
+            logger.error(`    ${red('Version not found in package.json!')}`);
+            logger.error(`    ${red('Please add a version to the package.json file before publishing.')}`);
+            return false;
+        }
+
+        if (!options.verbose) {
+            logTree(logger, 'Local Package Info', [
+                { label: `Name ${localPackageInfo.name}` },
+                { label: `Version ${localPackageInfo.version}` },
+                { label: `Description ${localPackageInfo.description}` },
+                { label: `Homepage ${localPackageInfo.homepage}` },
+                { label: `License ${localPackageInfo.license}` },
+                { label: `Maintainers ${localPackageInfo.maintainers?.map((m) => typeof m === 'string' ? m : m.name).join(', ')}` }
+            ], { prefixSpaceLength: 4 });
+        }
+
+        try {
+            const remotePackageInfo = await tryFetchRemotePackageInfo(localPackageInfo.name ?? '');
+
+            if (remotePackageInfo) {
+                if (!options.verbose) {
+                    logTree(logger, 'Remote Package Info', [
+                        { label: `Name ${remotePackageInfo.name}` },
+                        { label: `Version ${remotePackageInfo.version}` },
+                        { label: `Description ${remotePackageInfo.description}` },
+                        { label: `Homepage ${remotePackageInfo.homepage}` },
+                        { label: `License ${remotePackageInfo.license}` },
+                        { label: `Maintainers ${remotePackageInfo.maintainers?.map((m) => m.name).join(', ')}` }
+                    ], { prefixSpaceLength: 4 });
+                }
+
+                if (semver.compare(localPackageInfo.version, remotePackageInfo.version) !== 1) {
+                    logger.error(`    ${red('Version mismatch!')}`);
+                    logger.error(`    ${red('Local version:')} ${remotePackageInfo.version}`);
+                    logger.error(`    ${red('Remote version:')} ${remotePackageInfo.version}`);
+                    logger.error(`    ${red('Please update the version in package.json before publishing.')}`);
+                }
+            } else {
+                logger.info(`    ${yellow('Remote package not found. Proceeding with publish...')}`);
+            }
+        } catch (error) {
+            logger.error(red(error.message));
+            return false;
+        }
+
+        logger.info(`    ${magenta('Publishing package...')}`);
+
+        try {
+            if (!options.dryRun) {
+                const success = publishNpmPackage(outPath, logger, options);
+
+                if (!success) {
+                    logger.error(red('Failed to publish package.'));
+                }
+
+                return success;
+            }
+        } catch (error) {
+            logger.error(red(error instanceof Error ? error.message : String(error)));
+            return Promise.resolve(false);
+        }
+
+        return true;
+    }
+
+    function tryGetLocalPackageInfo(path: string): PackageJson | null {
+        const packageJsonPath = Path.combine(path, 'package.json');
+
+        if (!File.exists(packageJsonPath)) {
+            return null;
+        }
+
+        return File.readAllJson(packageJsonPath);
+    }
+
+    async function tryFetchRemotePackageInfo(packageName: string): Promise<INpmPackageInfo | null> {
+        const encoded = encodeURIComponent(packageName);
+        const url = `https://registry.npmjs.org/${encoded}`;
+
+        const res = await fetch(url);
+        if (!res.ok) {
+            if (res.status === 404) {
+                // throw new Error(`Remote (npm) package '${bold(packageName)}' not found.`);
+                return null;
+            }
+
+            throw new Error(`Failed to fetch package info for '${bold(packageName)}': ${res.statusText}`);
+        }
+
+        const data = await res.json();
+
+        if (data?.time?.unpublished) {
+            return null;
+        }
+
+        const latest = data['dist-tags'].latest;
+        const latestData = data.versions[latest];
+
+        return {
+            name: latestData.name,
+            version: latestData.version,
+            description: latestData.description,
+            homepage: latestData.homepage,
+            license: latestData.license,
+            maintainers: data.maintainers,
+            time: data.time,
+            distTags: data['dist-tags']
+        };
+    }
+
+    function publishNpmPackage(cwd: string, logger: ILogger, options: IPublishPackageTaskOptions): boolean {
+        try {
+            const packageJson = tryGetLocalPackageInfo(cwd);
+            if (!packageJson?.version) {
+                throw new Error('Missing version in local package.json.');
+            }
+
+            const prereleaseParts = semver.prerelease(packageJson.version);
+            const tag = prereleaseParts?.[0]; // 'beta', 'alpha', 'next', ...
+
+            const publishCommand = `npm publish --access public${tag ? ` --tag ${tag}` : ''}`;
+
+            logger.info(`    ${gray(`Executing: ${publishCommand}`)}`);
+
+            const output = execSync(publishCommand, {
+                cwd: cwd,
+                stdio: 'pipe',
+                maxBuffer: 1024 * 1024 * 10 // 10 MB
+            }).toString();
+
+            logger.info(`    ${green('Package published successfully!')}`);
+
+            if (options.verbose) {
+                output.split('\n').forEach((line) => {
+                    if (line.trim()) {
+                        logger.log(`    ${gray(line)}`);
+                    }
+                });
+            }
+
+            return true;
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            errorMessage.split('\n').forEach((line) => {
+                if (line.trim()) {
+                    logger.error(`    ${red(line)}`);
+                }
+            });
+
+            return false;
+        }
+    }
+
+}

package/src/executors/release-package/executor.ts

@@ -0,0 +1,33 @@
+// #region Imports
+
+import type { ExecutorContext } from '@nx/devkit';
+import { getProjectPackageJson } from '../../utils/getProjectPackageJson';
+import { getProjectRoot } from '../../utils/getProjectRoot';
+import { getProjectTsConfigJson } from '../../utils/getProjectTsConfigJson';
+import { isVerbose } from '../../utils/isVerbose';
+import type { PublishPackageTask } from './executor.task';
+
+// #endregion
+
+/**
+ * @public
+ */
+export type PublishPackageExecutorOptions = Omit<PublishPackageTask.IPublishPackageTaskOptions, 'cwd' | 'tsConfigJson' | 'packageJson'>;
+
+/**
+ * @public
+ */
+export default async function runExecutor(options: PublishPackageExecutorOptions, context: ExecutorContext): Promise<{ success: boolean }> {
+    const task = (await import('./executor.task')).PublishPackageTask;
+
+    return task.run({
+        cwd: getProjectRoot(context),
+        tsConfigJson: getProjectTsConfigJson(context),
+        packageJson: getProjectPackageJson(context),
+        outPath: options.outPath,
+        dryRun: options.dryRun,
+        verbose: isVerbose(context, options),
+    }).then((result) => ({ success: result }));
+}
+
+// #endregion

package/src/executors/release-package/schema.json

@@ -0,0 +1 @@
+{}

package/src/executors/release-package-json/executor.task.ts

@@ -0,0 +1,206 @@
+/* eslint-disable @typescript-eslint/no-dynamic-delete */
+/* eslint-disable max-depth */
+
+// #region Imports
+
+import { blue, bold, ConsoleLogger, File, logSeparator, Path, yellow } from '@breadstone-infrastructure/utilities';
+import type { PackageJson, TsConfigJson } from 'type-fest';
+import { validRange } from 'semver';
+
+// #endregion
+
+/**
+ * @description Task to copy and prepare the package for publication.
+ * @public
+ */
+export namespace CopyPublisherPackageJsonTask {
+
+    /**
+     * @public
+     */
+    export interface ICopyPublisherPackageJsonTaskOptions {
+        cwd: string;
+        keepLifecycleScripts: boolean;
+        checkPackageFiles: boolean;
+
+        /**
+         * If set to true, the task will remove all invalid dependencies from the package.json file.
+         * Means that only valid semver versions will be kept.
+         * 'file:' and 'workspace:*' for example are not valid semver versions and will be removed.
+         */
+        removeInvalidDependencies: boolean;
+        tsConfigJson: TsConfigJson;
+        packageJson: PackageJson;
+        // The transform function is used to transform the path of the file and the filename itself.
+        // The use case is that in your package.json you have a entry like "main": "../index.ts" and it should be "main": "./index.js"
+        transform?: (file: string) => string;
+    }
+
+    /**
+     * Recursively transforms paths in the "exports" field.
+     */
+    function transformExports(exports: PackageJson.Exports, transform: (file: string) => string): PackageJson.Exports {
+        if (typeof exports === 'string') {
+            return transform(exports);
+        } else if (Array.isArray(exports)) {
+            return exports
+                .map((item) => transformExports(item, transform))
+                .filter((item): item is Exclude<typeof item, null> => item !== null) as PackageJson.Exports;
+        } else if (exports && typeof exports === 'object') {
+            const transformed: PackageJson.ExportConditions = {};
+            for (const [key, value] of Object.entries(exports)) {
+                transformed[key] = transformExports(value, transform);
+            }
+            return transformed;
+        }
+        return exports;
+    }
+
+    /**
+     * @public
+     */
+    export async function run(options: ICopyPublisherPackageJsonTaskOptions): Promise<void> {
+        const logger = new ConsoleLogger();
+
+        logSeparator(logger, 'Copy Publisher Package Json');
+
+        // eslint-disable-next-line complexity
+        return new Promise<void>((resolve) => {
+            // 1. remove all unnecessary properties
+            const unnecessaryProps = [
+                'stylelint',
+                'prettier',
+                'browserslist',
+                'devDependencies',
+                'publishConfig',
+                'eslintConfig',
+                'workspaces',
+                'husky',
+                'files',
+                'nx',
+                options.keepLifecycleScripts ? '' : 'scripts'
+            ];
+            for (const prop of unnecessaryProps) {
+                if (prop in options.packageJson) {
+                    delete options.packageJson[prop];
+
+                    logger.log(`    ${bold(blue('[REMOVED]'))} ${prop}`);
+                }
+            }
+
+            // 1.1. check for invalid semver versions
+            const depsSections = ['dependencies', 'peerDependencies'] as const;
+
+            for (const section of depsSections) {
+                const deps = options.packageJson[section];
+                if (deps && typeof deps === 'object') {
+                    for (const [pkg, version] of Object.entries(deps)) {
+                        if (typeof version !== 'string' || !validRange(version)) {
+                            logger.warn(bold(yellow(`    Invalid semver version for "${pkg}" in "${section}": "${version}".`)));
+
+                            if (options.removeInvalidDependencies) {
+                                delete deps[pkg];
+                                logger.info(`    ${bold(blue('[REMOVED]'))} "${pkg}" from "${section}" due to invalid semver.`);
+                            }
+                        }
+                    }
+
+                    if (Object.keys(deps).length === 0) {
+                        delete options.packageJson[section];
+                        logger.log(`    ${bold(blue('[REMOVED]'))} Entire "${section}" section due to no valid entries.`);
+                    }
+                }
+            }
+
+            // 2. modify all potential path properties
+            const potentialPathProps = [
+                'main',
+                'module',
+                'commonjs',
+                'typings',
+                'types',
+                'es2020',
+                'esm2020',
+                'fesm2020',
+                'es2015',
+                'fesm2015',
+                'metadata',
+                'style',
+                'sass',
+                'customElements',
+                'exports',
+                'typesVersions'
+            ];
+            for (const prop of potentialPathProps) {
+                if (prop in options.packageJson) {
+                    if (prop === 'exports') {
+                        if (options.packageJson.exports) {
+                            options.packageJson.exports = transformExports(options.packageJson.exports, (file) => {
+                                const segments = Path.getDirectorySegments(file);
+                                segments.shift();
+                                segments.push(Path.getFileName(file));
+                                return options.transform
+                                    ? options.transform(`./${segments.join('/')}`)
+                                    : `./${segments.join('/')}`;
+                            });
+                        }
+                        logger.log(`    ${bold(blue('[CHANGED]'))} ${prop}`);
+                    } else if (typeof options.packageJson[prop] !== 'string') {
+                        logger.warn(`    ${bold(yellow('[WARNING]'))} "###`);
+                        logger.warn(`    ${bold(yellow('[WARNING]'))} "${prop}" is not a string. Skipping...`);
+                        logger.warn(`    ${bold(yellow('[WARNING]'))} "###`);
+                        continue;
+                    } else {
+                        const p = options.packageJson[prop];
+                        const segments = Path.getDirectorySegments(p);
+                        segments.shift();
+                        segments.push(Path.getFileName(p));
+
+                        options.packageJson[prop] = options.transform
+                            ? options.transform(`./${segments.join('/')}`)
+                            : `./${segments.join('/')}`;
+
+                        logger.log(`    ${bold(blue('[CHANGED]'))} ${prop}`);
+
+                        if (options.checkPackageFiles) {
+                            if (!File.exists(Path.combine(options.cwd, options.tsConfigJson.compilerOptions?.outDir ?? '', options.packageJson[prop] ?? ''))) {
+                                logger.warn(`${prop} file in package.json does not exist.`);
+                                logger.info(`${prop} searched in path '${Path.combine(options.cwd, options.tsConfigJson.compilerOptions?.outDir ?? '', options.packageJson[prop] ?? '')}'.`, { color: 'gray' });
+                            }
+                        }
+                    }
+                }
+            }
+
+            // 3. safe package.json in dist directory
+            const pkgDistPath = Path.combine(options.cwd, options.tsConfigJson.compilerOptions?.outDir ?? '', 'package.json');
+            File.writeAllJson(pkgDistPath, options.packageJson);
+
+            // 4. copy additional files to the dist directory
+            const distPath = Path.combine(options.cwd, options.tsConfigJson.compilerOptions?.outDir ?? '');
+            const filesToCopy = [
+                './LICENSE',
+                './README.md',
+                './CHANGELOG.md',
+                './SECURITY.md',
+                './CODE_OF_CONDUCT.md',
+                './CONTRIBUTING.md'
+            ];
+            filesToCopy.map((x) => Path.combine(options.cwd, x)).forEach((x) => {
+                if (!File.exists(x)) {
+                    logger.warn(`    ${bold(yellow('[COPY]'))} File "${x}" does not exist.`);
+                    return;
+                }
+
+                File.copy(x, Path.combine(distPath, Path.getFileName(x)));
+                logger.info(`    ${bold(blue('[COPY]'))} ${Path.getFileName(x)}`);
+            });
+
+            resolve();
+        }).finally(() => {
+            logger.log('');
+            logSeparator(logger);
+        });
+    }
+
+}

package/src/executors/release-package-json/executor.ts

@@ -0,0 +1,37 @@
+// #region Imports
+
+import type { ExecutorContext } from '@nx/devkit';
+import { getProjectPackageJson } from '../../utils/getProjectPackageJson';
+import { getProjectRoot } from '../../utils/getProjectRoot';
+import { getProjectTsConfigJson } from '../../utils/getProjectTsConfigJson';
+import type { CopyPublisherPackageJsonTask } from './executor.task';
+
+// #endregion
+
+/**
+ * @public
+ */
+export type CopyPublisherPackageJsonExecutorOptions = Omit<CopyPublisherPackageJsonTask.ICopyPublisherPackageJsonTaskOptions, 'cwd' | 'tsConfigJson' | 'packageJson' | 'verbose'>;
+
+/**
+ * @public
+ */
+export default async function runExecutor(options: CopyPublisherPackageJsonExecutorOptions, context: ExecutorContext): Promise<{ success: boolean }> {
+    try {
+        const task = (await import('./executor.task')).CopyPublisherPackageJsonTask;
+
+        await task.run({
+            cwd: getProjectRoot(context),
+            tsConfigJson: getProjectTsConfigJson(context),
+            packageJson: getProjectPackageJson(context),
+            checkPackageFiles: options.checkPackageFiles,
+            keepLifecycleScripts: options.keepLifecycleScripts,
+            removeInvalidDependencies: options.removeInvalidDependencies,
+            transform: options.transform
+        });
+        return { success: true };
+    } catch (error) {
+        console.error(error);
+        return { success: false };
+    }
+}

package/src/executors/release-package-json/schema.json

@@ -0,0 +1 @@
+{}

package/src/executors/scss-style-bundle/executor.task.ts

@@ -0,0 +1,123 @@
+// #region Imports
+
+import { ArrayExtensions, ConsoleLogger, File, type IFileCacheOptions, logPair, logSeparator, magenta, NoFilesFoundToCreateError, Path, StringExtensions } from '@breadstone-infrastructure/utilities';
+import type { PackageJson } from 'type-fest';
+import { withCaching } from '../../utils/withCaching';
+
+// #endregion
+
+/**
+ * @description Task to generate scss styles bundle.
+ * @public
+ */
+export namespace StylesBundleTask {
+
+    export interface IStylesBundleTaskOptions {
+        cwd: string;
+        packageJson: PackageJson;
+        cache?: IFileCacheOptions;
+        files?: Array<{
+            removeInternalImports?: boolean;
+            src: string | Array<string>;
+            dest: string;
+        }>;
+        verbose?: boolean;
+    }
+
+    export async function run(options: IStylesBundleTaskOptions): Promise<void> {
+        const logger = new ConsoleLogger();
+
+        logSeparator(logger, 'Styles Bundle');
+
+        const fileCache = withCaching(options.cache);
+
+        const lookups = new Array<{
+            options: {
+                removeInternalImports: boolean;
+            };
+            in: string | Array<string>;
+            out: string;
+        }>();
+
+        options.files?.forEach((file) => {
+            lookups.push({
+                options: {
+                    removeInternalImports: file.removeInternalImports ?? false
+                },
+                in: ArrayExtensions.arrayify(file.src).map((x) => Path.combine(options.cwd, x)),
+                out: file.dest
+            });
+        });
+
+        if (lookups.length === 0 && options.verbose) {
+            logger.warn('No files found to create the bundle.');
+        }
+
+        for (const lookup of lookups) {
+            const files = File.glob(lookup.in);
+
+            if (files.length === 0) {
+                ArrayExtensions.arrayify(lookup.in).forEach((x) => {
+                    logger.warn('No files found to create the bundle.');
+                    logger.warn(`  Search pattern: ${x}`);
+                });
+            }
+
+            // const hasCachedDirs = (await Promise.all(ArrayExtensions.arrayify(lookup.in)
+            //     .map(async (x) => fileCache.isDirectoryCached(x))))
+            //     .some((x) => x);
+
+            // if (!hasCachedDirs) {
+            if (files.length) {
+                const dest = Path.combine(options.cwd, lookup.out);
+                let content = files.map((x) => File.readAllText(x)).join(StringExtensions.newLine);
+                content = processContent(content, lookup.options.removeInternalImports);
+                File.writeAllText(dest, normalizeLineBreaks(content));
+
+                logPair(logger, magenta(`from: ${Array.isArray(lookup.in) ? 'Multiple files' : lookup.in}`), magenta(`to:   ${dest}`));
+            } else {
+                logger.warn(new NoFilesFoundToCreateError(lookup.out).message);
+            }
+            // } else {
+            //     logger.log(gray('\tFile or Folder is up to date.'));
+            // }
+        }
+
+        logSeparator(logger);
+    }
+
+}
+
+function processContent(content: string, removeInternalImports: boolean): string {
+    const aliases = new Set<string>();
+    const useStatements = new Set<string>();
+    const useRegex = /@use ['"](.+?)['"](?: as (\w+))?;/g;
+
+    if (removeInternalImports) {
+        content = content.replace(useRegex, (match, importPath, alias) => {
+            if (importPath.startsWith('sass:')) {
+                useStatements.add(match);
+                return '';
+            }
+
+            if (alias) {
+                aliases.add(alias);
+            }
+
+            return '';
+        });
+    }
+
+    aliases.forEach((alias) => {
+        const aliasRegex = new RegExp(`\\b${alias}\\.`, 'g');
+        content = content.replace(aliasRegex, '');
+    });
+
+    return `${Array.from(useStatements).join('\n')}\n\n${content.trim()}`;
+}
+
+export function normalizeLineBreaks(content: string): string {
+    return content
+        .replace(/(\r?\n){2,}/g, '\n')
+        .trim();
+}

package/src/executors/scss-style-bundle/executor.ts

@@ -0,0 +1,37 @@
+
+// #region Imports
+
+import { Path } from '@breadstone-infrastructure/utilities';
+import type { ExecutorContext } from '@nx/devkit';
+import { getProjectPackageJson } from '../../utils/getProjectPackageJson';
+import { getProjectRoot } from '../../utils/getProjectRoot';
+import { isVerbose } from '../../utils/isVerbose';
+import type { StylesBundleTask } from './executor.task';
+
+// #endregion
+
+export type StylesBundleExecutorOptions = Omit<StylesBundleTask.IStylesBundleTaskOptions, 'cwd' | 'tsConfigJson' | 'packageJson'>;
+
+/**
+ * @public
+ */
+export default async function runExecutor(options: StylesBundleExecutorOptions, context: ExecutorContext): Promise<{ success: boolean }> {
+    try {
+        const task = (await import('./executor.task')).StylesBundleTask;
+
+        await task.run({
+            cwd: getProjectRoot(context),
+            packageJson: getProjectPackageJson(context),
+            cache: {
+                enabled: options.cache?.enabled ?? context.target?.cache ?? false,
+                dirPath: Path.combine(getProjectRoot(context), '.cache')
+            },
+            files: options.files,
+            verbose: isVerbose(context, options),
+        });
+        return { success: true };
+    } catch (error) {
+        console.error(error);
+        return { success: false };
+    }
+}

package/src/executors/scss-style-bundle/schema.json

@@ -0,0 +1 @@
+{}