@nlabs/lex
Version:
443 lines (440 loc) • 68.5 kB
JavaScript
/**
* Copyright (c) 2018-Present, Nitrogen Labs, Inc.
* Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
*/ import { transform } from '@swc/core';
import { execa } from 'execa';
import { existsSync, readFileSync } from 'fs';
import { sync as globSync } from 'glob';
import { dirname, relative as pathRelative, resolve as pathResolve } from 'path';
import { LexConfig } from '../../LexConfig.js';
import { checkLinkedModules, copyConfiguredFiles, createSpinner, handleWebpackProgress, removeFiles } from '../../utils/app.js';
import { resolveWebpackPaths, getLexPackageJsonPath, resolveBinaryPath } from '../../utils/file.js';
import { log } from '../../utils/log.js';
import { processTranslations } from '../../utils/translations.js';
import { aiFunction } from '../ai/ai.js';
import boxen from 'boxen';
import chalk from 'chalk';
let currentFilename;
let currentDirname;
try {
currentFilename = eval('require("url").fileURLToPath(import.meta.url)');
currentDirname = dirname(currentFilename);
} catch {
currentFilename = process.cwd();
currentDirname = process.cwd();
}
const displayBuildStatus = (bundler, outputPath, quiet, stats)=>{
if (quiet) return;
let statsInfo = '';
if (stats && stats.modules && stats.assets) {
statsInfo = `\n${chalk.green('Modules:')} ${chalk.cyan(stats.modules)}\n` + `${chalk.green('Assets:')} ${chalk.cyan(stats.assets)}\n` + `${chalk.green('Size:')} ${chalk.cyan(stats.size)}\n`;
}
const statusBox = boxen(`${chalk.cyan.bold('🏗️ Build Completed Successfully ')}\n\n` + `${chalk.green('Bundler:')} ${chalk.cyan(bundler)}\n` + `${chalk.green('Output:')} ${chalk.underline(outputPath)}${statsInfo}\n` + `${chalk.yellow('Ready for deployment! 🚀')}`, {
padding: 1,
margin: 1,
borderStyle: 'round',
borderColor: 'green',
backgroundColor: '#1a1a1a'
});
console.log('\n' + statusBox + '\n');
};
export const buildWithSWC = async (spinner, commandOptions, callback)=>{
const { cliName = 'Lex', format = 'esm', outputPath, quiet, sourcePath, watch } = commandOptions;
const { outputFullPath, sourceFullPath, swc: swcConfig, targetEnvironment, useGraphQl, useTypescript } = LexConfig.config;
const sourceDir = sourcePath ? pathResolve(process.cwd(), `./${sourcePath}`) : sourceFullPath || '';
const globOptions = {
absolute: true,
cwd: sourceDir,
dot: false,
nodir: true,
nosort: true
};
const tsFiles = globSync(`**/!(*.spec|*.test).ts*`, globOptions);
const jsFiles = globSync(`**/!(*.spec|*.test).js`, globOptions);
const sourceFiles = [
...tsFiles,
...jsFiles
];
const outputDir = outputPath ? pathResolve(process.cwd(), outputPath) : outputFullPath || pathResolve(process.cwd(), './lib');
try {
spinner.start('Building with SWC...');
const transformPromises = sourceFiles.map(async (file)=>{
const fileRelativeToSource = pathRelative(sourceDir, file);
const sourcePath = file; // file is already absolute
const outputFile = fileRelativeToSource.replace(/\.(ts|tsx)$/, '.js');
const outputPath = pathResolve(outputDir, outputFile);
const outputDirPath = dirname(outputPath);
if (!existsSync(outputDirPath)) {
const { mkdirSync } = await import('fs');
mkdirSync(outputDirPath, {
recursive: true
});
}
const sourceCode = readFileSync(sourcePath, 'utf8');
const swcOptions = {
...swcConfig,
filename: file,
module: {
type: format === 'cjs' ? 'commonjs' : swcConfig?.module?.type || 'es6',
...swcConfig?.module
}
};
const result = await transform(sourceCode, swcOptions);
const { writeFileSync } = await import('fs');
writeFileSync(outputPath, result.code);
});
await Promise.all(transformPromises);
spinner.succeed('Build completed with SWC');
displayBuildStatus('SWC', outputDir, quiet);
callback(0);
return 0;
} catch (error) {
log(`\n${commandOptions.cliName || 'Lex'} Error: SWC build failed`, 'error', quiet);
log(`\nError: ${error.message}`, 'error', quiet);
if (error instanceof Error) {
if (error.stack) {
log(`\nStack Trace:\n${error.stack}`, 'error', quiet);
}
if ('filename' in error || 'file' in error) {
log(`\nFile: ${error.filename || error.file}`, 'error', quiet);
}
}
spinner.fail('Build failed with SWC');
if (!quiet) {
console.error('\nFull Error Details:', error);
}
callback(1);
return 1;
}
};
export const buildWithWebpack = async (spinner, cmd, callback)=>{
const { analyze, cliName = 'Lex', config, configName, defineProcessEnvNodeEnv, devtool, disableInterpret, entry, env, failOnWarnings, json, merge, mode, name, nodeEnv, noDevtool, noStats, noTarget, noWatch, noWatchOptionsStdin, outputPath, quiet = false, stats, target, watch, watchOptionsStdin } = cmd;
const entryValue = Array.isArray(entry) ? entry[0] : entry;
let webpackConfig;
if (config) {
const isRelativeConfig = config.substr(0, 2) === './';
webpackConfig = isRelativeConfig ? pathResolve(process.cwd(), config) : config;
} else {
const projectConfigPath = pathResolve(process.cwd(), 'webpack.config.js');
const projectConfigPathTs = pathResolve(process.cwd(), 'webpack.config.ts');
const hasProjectConfig = existsSync(projectConfigPath) || existsSync(projectConfigPathTs);
if (hasProjectConfig) {
webpackConfig = existsSync(projectConfigPathTs) ? projectConfigPathTs : projectConfigPath;
} else {
const { webpackConfig: resolvedConfig } = resolveWebpackPaths(currentDirname);
webpackConfig = resolvedConfig;
}
}
if (!existsSync(webpackConfig)) {
const lexPackagePath = getLexPackageJsonPath();
const lexPackageDir = dirname(lexPackagePath);
const lexWebpackConfig = pathResolve(lexPackageDir, 'webpack.config.js');
if (existsSync(lexWebpackConfig)) {
webpackConfig = lexWebpackConfig;
console.log('Using Lex webpack config:', webpackConfig);
} else {
log(`\n${cliName} Error: Could not find webpack.config.js`, 'error', quiet);
spinner.fail('Build failed.');
callback(1);
return 1;
}
}
const webpackOptions = [
'--color',
'--progress',
'--config',
webpackConfig
];
if (analyze) webpackOptions.push('--analyze');
if (configName) webpackOptions.push('--configName', configName);
if (defineProcessEnvNodeEnv) webpackOptions.push('--defineProcessEnvNodeEnv', defineProcessEnvNodeEnv);
if (devtool) webpackOptions.push('--devtool', devtool);
if (disableInterpret) webpackOptions.push('--disableInterpret');
if (entryValue) webpackOptions.push('--entry', entryValue.toString());
if (env) webpackOptions.push('--env', env);
if (failOnWarnings) webpackOptions.push('--failOnWarnings');
if (json) webpackOptions.push('--json', json);
if (mode) webpackOptions.push('--mode', mode);
if (merge) webpackOptions.push('--merge');
if (name) webpackOptions.push('--name', name);
if (noDevtool) webpackOptions.push('--noDevtool');
if (noStats) webpackOptions.push('--noStats');
if (noTarget) webpackOptions.push('--noTarget');
if (noWatch) webpackOptions.push('--noWatch');
if (noWatchOptionsStdin) webpackOptions.push('--noWatchOptionsStdin');
if (nodeEnv) webpackOptions.push('--nodeEnv', nodeEnv);
if (outputPath) webpackOptions.push('--output-path', outputPath.toString()); // Convert to string
if (stats) webpackOptions.push('--stats', stats);
if (target) webpackOptions.push('--target', target);
if (watch) webpackOptions.push('--watch');
if (watchOptionsStdin) webpackOptions.push('--watchOptionsStdin');
try {
const { webpackPath } = resolveWebpackPaths(currentDirname);
let executablePath = webpackPath;
let finalWebpackOptions;
if (webpackPath === 'npx') {
finalWebpackOptions = [
'webpack',
...webpackOptions
];
} else if (webpackPath.endsWith('.js')) {
executablePath = 'node';
finalWebpackOptions = [
webpackPath,
...webpackOptions
];
} else {
finalWebpackOptions = [
...webpackOptions
];
}
const childProcess = execa(executablePath, finalWebpackOptions, {
encoding: 'utf8',
stdio: 'pipe'
});
let buildCompleted = false;
let buildStats = {
modules: 0,
assets: 0,
size: '0 B'
};
childProcess.stdout?.on('data', (data)=>{
const output = data.toString();
handleWebpackProgress(output, spinner, quiet, '🏗️', 'Webpack Building');
if (!buildCompleted && output.includes('compiled successfully')) {
buildCompleted = true;
spinner.succeed('Build completed successfully!');
const moduleMatch = output.match(/(\d+) modules/);
const assetMatch = output.match(/(\d+) assets/);
const sizeMatch = output.match(/assets by status ([\d.]+ \w+)/) || output.match(/assets by path.*?([\d.]+ \w+)/);
if (moduleMatch) buildStats.modules = parseInt(moduleMatch[1], 10);
if (assetMatch) buildStats.assets = parseInt(assetMatch[1], 10);
if (sizeMatch) buildStats.size = sizeMatch[1];
displayBuildStatus('webpack', LexConfig.config.outputFullPath || 'lib', quiet, buildStats);
}
});
childProcess.stderr?.on('data', (data)=>{
const output = data.toString();
handleWebpackProgress(output, spinner, quiet, '🏗️', 'Webpack Building');
if (!buildCompleted && output.includes('compiled successfully')) {
buildCompleted = true;
spinner.succeed('Build completed successfully!');
const moduleMatch = output.match(/(\d+) modules/);
const assetMatch = output.match(/(\d+) assets/);
const sizeMatch = output.match(/assets by status ([\d.]+ \w+)/) || output.match(/assets by path.*?([\d.]+ \w+)/);
if (moduleMatch) buildStats.modules = parseInt(moduleMatch[1], 10);
if (assetMatch) buildStats.assets = parseInt(assetMatch[1], 10);
if (sizeMatch) buildStats.size = sizeMatch[1];
displayBuildStatus('webpack', LexConfig.config.outputFullPath || 'lib', quiet, buildStats);
}
});
await childProcess;
if (!buildCompleted) {
spinner.succeed('Build completed successfully!');
displayBuildStatus('webpack', LexConfig.config.outputFullPath || 'lib', quiet, buildStats);
}
callback(0);
return 0;
} catch (error) {
log(`\n${cliName} Error: Webpack build failed`, 'error', quiet);
log(`\nError: ${error.message}`, 'error', quiet);
if (error instanceof Error) {
if (error.stack) {
log(`\nStack Trace:\n${error.stack}`, 'error', quiet);
}
}
log(`\nWebpack Options: ${webpackOptions.slice(0, 5).join(' ')}...`, 'error', quiet);
spinner.fail('Build failed.');
if (cmd.assist) {
spinner.start('AI is analyzing the webpack error...');
try {
await aiFunction({
prompt: `Fix this webpack build error: ${error.message}\n\nError details:\n${error.toString()}\n\nConfiguration used:\n${JSON.stringify(webpackOptions, null, 2)}`,
task: 'help',
context: true,
quiet
});
spinner.succeed('AI analysis complete');
} catch (aiError) {
spinner.fail('Could not generate AI assistance');
if (!quiet) {
console.error('AI assistance error:', aiError);
}
}
}
if (!quiet) {
console.error('\nFull Error Details:', error);
}
callback(1);
return 1;
}
};
export const build = async (cmd, callback = ()=>({}))=>{
const { bundler = 'webpack', cliName = 'Lex', quiet = false, remove = false, test = false, translations = false, variables = '{}' } = cmd;
const spinner = createSpinner(quiet);
log(`${cliName} building...`, 'info', quiet);
await LexConfig.parseConfig(cmd);
const { outputFullPath, useTypescript } = LexConfig.config;
checkLinkedModules();
let variablesObj = {
NODE_ENV: 'production'
};
if (variables) {
try {
variablesObj = JSON.parse(variables);
} catch (error) {
log(`\n${cliName} Error: Environment variables option is not a valid JSON object.`, 'error', quiet);
callback(1);
return 1;
}
}
process.env = {
...process.env,
...variablesObj
};
if (test) {
log('Test mode: Build environment loaded, exiting', 'info', quiet);
callback(0);
return 0;
}
if (translations) {
spinner.start('Processing translations...');
try {
const sourcePath = LexConfig.config.sourceFullPath || process.cwd();
const outputPath = LexConfig.config.outputFullPath || 'lib';
await processTranslations(sourcePath, outputPath, quiet);
spinner.succeed('Translations processed successfully!');
} catch (translationError) {
log(`\n${cliName} Error: Failed to process translations: ${translationError.message}`, 'error', quiet);
spinner.fail('Failed to process translations.');
callback(1);
return 1;
}
}
spinner.start('Building code...');
if (remove) {
await removeFiles(outputFullPath || '');
}
let buildResult = 0;
if (bundler === 'swc') {
buildResult = await buildWithSWC(spinner, cmd, (status)=>{
buildResult = status;
});
} else {
buildResult = await buildWithWebpack(spinner, cmd, (status)=>{
buildResult = status;
});
}
if (buildResult === 0 && cmd.analyze) {
spinner.start('AI is analyzing the build output for optimization opportunities...');
try {
const stats = {
outputPath: LexConfig.config.outputFullPath,
entryPoints: bundler === 'swc' ? `Source files: ${LexConfig.config.sourceFullPath}/**/*.{ts,js}` : LexConfig.config.webpack?.entry || 'Unknown entry points'
};
await aiFunction({
prompt: `Analyze this build for optimization opportunities:
Build Type: ${bundler}
Format: ${cmd.format || 'default'}
Environment: ${LexConfig.config.targetEnvironment}
${JSON.stringify(stats, null, 2)}
What are the key optimization opportunities for this build configuration? Consider:
1. Bundle size optimization strategies
2. Code splitting recommendations
3. Tree-shaking improvements
4. Performance enhancements
5. Dependency optimizations`,
task: 'optimize',
context: true,
quiet
});
spinner.succeed('AI build analysis complete');
} catch (aiError) {
spinner.fail('Could not generate AI optimization analysis');
if (!quiet) {
console.error('AI analysis error:', aiError);
}
}
}
if (buildResult === 0) {
try {
if (useTypescript && bundler === 'swc') {
const typescriptPath = resolveBinaryPath('tsc', 'typescript');
if (typescriptPath) {
spinner.start('Generating TypeScript declarations...');
try {
const sourceFullPath = LexConfig.config.sourceFullPath || pathResolve(process.cwd(), './src');
const outputFullPath = LexConfig.config.outputFullPath || pathResolve(process.cwd(), './lib');
const globOptions = {
cwd: sourceFullPath,
dot: false,
nodir: true,
absolute: true
};
const tsFiles = globSync(`**/!(*.spec|*.test|*.integration).ts`, globOptions);
const tsxFiles = globSync(`**/!(*.spec|*.test|*.integration).tsx`, globOptions);
const allSourceFiles = [
...tsFiles,
...tsxFiles
];
const typescriptOptions = [
...LexConfig.getTypeScriptDeclarationFlags(),
...allSourceFiles
];
const result = await execa(typescriptPath, typescriptOptions, {
encoding: 'utf8',
cwd: process.cwd(),
reject: false,
all: true
});
if (result.exitCode !== 0) {
const hasDeclarations = result.all?.includes('Writing') || result.all?.includes('Declaration') || false;
const errorOutput = result.stderr || result.stdout || result.all || 'Unknown error';
if (!hasDeclarations) {
log(`\n${cliName} Error: TypeScript declaration generation failed`, 'error', quiet);
log(`\nExit Code: ${result.exitCode}`, 'error', quiet);
log(`\nTypeScript Command: ${typescriptPath} ${typescriptOptions.slice(0, 10).join(' ')}...`, 'error', quiet);
log(`\nError Output:\n${errorOutput}`, 'error', quiet);
const errorLines = errorOutput.split('\n').filter((line)=>line.includes('error TS') || line.includes('Error:') || line.trim().startsWith('src/') || line.trim().startsWith('TS'));
if (errorLines.length > 0) {
log(`\nKey Errors:`, 'error', quiet);
errorLines.slice(0, 10).forEach((line)=>{
log(` ${line}`, 'error', quiet);
});
if (errorLines.length > 10) {
log(` ... and ${errorLines.length - 10} more errors`, 'error', quiet);
}
}
spinner.fail('TypeScript declaration generation had errors (continuing anyway).');
} else {
log(`\n${cliName} Warning: TypeScript declaration generation completed with errors`, 'warn', quiet);
if (!quiet && errorOutput) {
log(`\nWarnings:\n${errorOutput}`, 'warn', quiet);
}
spinner.succeed('TypeScript declarations generated (with warnings).');
}
} else {
spinner.succeed('TypeScript declarations generated!');
}
} catch (error) {
log(`\n${cliName} Error: TypeScript declaration generation exception`, 'error', quiet);
log(`\nError: ${error.message}`, 'error', quiet);
if (error instanceof Error && error.stack) {
log(`\nStack:\n${error.stack}`, 'error', quiet);
}
spinner.fail('TypeScript declaration generation had issues (continuing anyway).');
}
}
}
await copyConfiguredFiles(spinner, LexConfig.config, quiet);
} catch (copyError) {
log(`\n${cliName} Error: Failed to copy configured files: ${copyError.message}`, 'error', quiet);
callback(1);
return 1;
}
}
callback(buildResult);
return buildResult;
};
export default build;
//# sourceMappingURL=data:application/json;base64,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