@mschauer5/spfx-toolkit 1.0.10 → 1.0.11

package/src/commands/scripts.command.ts

@@ -0,0 +1,143 @@
+import { logger, util } from '../common';
+import spawn from 'cross-spawn';
+import { promises as fsPromises } from 'fs';
+import os from 'os';
+import path from 'path';
+import { incrementVersion, syncVersion } from './version.command';
+
+function getProjectConfigPaths() {
+  const configDir = path.join(process.cwd());
+  const configPath = path.join(configDir, 'package.json');
+  return { configDir, configPath };
+}
+
+async function getScriptValue(scriptName: string, configPath: string): Promise<any> {
+  try {
+    const fileExists = await util.checkIfFileExistsAsync(configPath, false);
+    if (!fileExists) {
+      return undefined;
+    }
+
+    const isGulp = await util.isUsingGulp();
+    let suffix = ':heft';
+    if (isGulp) {
+      suffix = ':gulp';
+    }
+
+    const data = await fsPromises.readFile(configPath, 'utf-8');
+    const config = JSON.parse(data);
+    if (config && typeof config === 'object' && config.scripts) {
+      const scriptWithSuffix = scriptName + suffix;
+      const hasBase = scriptName in config.scripts;
+      const hasSuffix = scriptWithSuffix in config.scripts;
+      if (hasBase && hasSuffix) {
+        return config.scripts[scriptWithSuffix];
+      } else if (hasSuffix) {
+        return config.scripts[scriptWithSuffix];
+      } else if (hasBase) {
+        return config.scripts[scriptName];
+      }
+    }
+    return undefined;
+  } catch (err) {
+    // File does not exist or cannot be read
+    return undefined;
+  }
+}
+
+async function getScriptByName(scriptName: string): Promise<string | undefined> {
+  const globalPath = util.getGlobalConfigPaths();
+  const localPath = getProjectConfigPaths();
+  let value = undefined;
+  value = await getScriptValue(scriptName, globalPath.configPath);
+
+  const localValue = await getScriptValue(scriptName, localPath.configPath);
+  if (localValue !== undefined) {
+    value = localValue;
+  }
+
+  return value;
+}
+
+export const run = async (scriptName: string, options?: any) => {
+  if (scriptName === 'bundle' && options && typeof options === 'string') {
+    if (options) {
+      incrementVersion(options as 'major' | 'minor' | 'patch');
+    } else {
+      syncVersion();
+    }
+  }
+
+  if (scriptName === 'serve') {
+    const isGulp = await util.isUsingGulp();
+    if (isGulp) {
+      const envFilePath = path.join(process.cwd(), '.env');
+      const envFileExists = await util.checkIfFileExistsAsync(envFilePath, false);
+      if (envFileExists) {
+        const envContent = await fsPromises.readFile(envFilePath, 'utf-8');
+        const lines = envContent.split(/\r?\n/);
+        const envVars: { [key: string]: string } = {};
+        for (const line of lines) {
+          const [key, value] = line.split('=');
+          if (key && value) {
+            envVars[key.trim()] = value.trim();
+          }
+        }
+        if (envVars['tenantDomain']) {
+          process.env['SPFX_SERVE_TENANT_DOMAIN'] = envVars['tenantDomain'];
+        }
+      }
+    }
+  }
+
+  const value = await getScriptByName(scriptName);
+  if (!value) {
+    logger.error(`Script name '${scriptName}' not found in either local or global package.json!`);
+  } else {
+    try {
+      spawn.sync(value, { stdio: 'inherit', shell: true, cwd: process.cwd() });
+    } catch (error) {
+      logger.error(error);
+    }
+  }
+};
+
+export const sync = async (scriptName: string, to: 'global' | 'local') => {
+  const { configPath: globalConfigPath } = util.getGlobalConfigPaths();
+  const { configPath: localConfigPath } = getProjectConfigPaths();
+  let sourcePath = to === 'local' ? globalConfigPath : localConfigPath;
+
+  const scriptValue = await getScriptValue(scriptName, sourcePath);
+  if (!scriptValue) {
+    logger.error(`Source script name '${scriptName}' not found in the ${sourcePath}!`);
+    return;
+  }
+
+  const targetPath = to === 'local' ? localConfigPath : globalConfigPath;
+  const targetExists = await util.checkIfFileExistsAsync(targetPath, false);
+  if (!targetExists) {
+    logger.error(`Target package.json does not exist at path: ${targetPath}`);
+    return;
+  }
+  const data = await fsPromises.readFile(targetPath, 'utf-8');
+  const targetConfig = JSON.parse(data);
+  if (!targetConfig.scripts) {
+    targetConfig.scripts = {};
+  }
+
+  const isGulp = await util.isUsingGulp();
+  let suffix = ':heft';
+  const orgScriptName = scriptName;
+  if (isGulp) {
+    suffix = ':gulp';
+  }
+  if (to === 'global') {
+    scriptName = scriptName + suffix;
+  }
+
+  targetConfig.scripts[scriptName] = scriptValue;
+
+  await fsPromises.writeFile(targetPath, JSON.stringify(targetConfig, null, 2), 'utf-8');
+
+  logger.log(`Synchronized script '${orgScriptName}' to ${targetPath}`);
+};

package/src/common/index.ts

@@ -1,4 +1,5 @@
 import { logger } from './logger';
 import * as constants from './constants';
 import * as util from './util';
+// import * as settings from '../commands/settings';
 export { logger, constants, util };

package/src/common/util.ts

@@ -1,12 +1,7 @@
 import { promises as fsPromises } from 'fs';
 import os from 'os';
 import path from 'path';
-
-function getConfigPaths() {
-  const configDir = path.join(os.homedir(), '.spfx-toolkit');
-  const configPath = path.join(configDir, 'config.json');
-  return { configDir, configPath };
-}
+import { logger } from './logger';
 
 export async function checkIfFileExistsAsync(filename, includeError = true) {
   try {
@@ -20,36 +15,97 @@ export async function checkIfFileExistsAsync(filename, includeError = true) {
   }
 }
 
+export function getGlobalConfigPaths() {
+  const configDir = path.join(os.homedir(), '.spfx-toolkit');
+  const configPath = path.join(configDir, 'package.json');
+  return { configDir, configPath };
+}
+
 export async function isUsingGulp(): Promise<boolean> {
   const gulpFile = 'gulpfile.js';
   return await checkIfFileExistsAsync(gulpFile, false);
 }
 
-export async function getScriptNameRunType(scriptName: string): Promise<any> {
-  const { configPath } = getConfigPaths();
-  try {
-    const data = await fsPromises.readFile(configPath, 'utf-8');
-    const config = JSON.parse(data);
-    if (config && typeof config === 'object' && scriptName in config) {
-      return config[scriptName];
+async function ensureGlobalPackageJsonExists() {
+  const { configDir, configPath } = getGlobalConfigPaths();
+  const exists = await checkIfFileExistsAsync(configPath, false);
+  if (!exists) {
+    await fsPromises.mkdir(configDir, { recursive: true });
+    await fsPromises.writeFile(configPath, JSON.stringify({ scripts: {} }, null, 2), 'utf-8');
+  }
+}
+
+export async function openGlobalPackageJsonInEditor() {
+  const { configPath } = getGlobalConfigPaths();
+  await ensureGlobalPackageJsonExists();
+
+  const spawn = require('child_process').spawn;
+  // Open the global package.json in VS Code
+  spawn(process.platform === 'win32' ? 'code.cmd' : 'code', [configPath], {
+    stdio: 'inherit',
+    shell: true
+  });
+}
+
+export async function initGlobalPackageJsonWithDefaults(force?: boolean) {
+  const { configPath } = getGlobalConfigPaths();
+  ensureGlobalPackageJsonExists();
+
+  const defaultScripts = {
+    'build:gulp': 'gulp build',
+    'build:heft': 'heft build',
+    'bundle:gulp': 'gulp clean && gulp bundle --ship && gulp package-solution --ship',
+    'bundle:heft': 'heft build --clean && heft package',
+    'serve:heft': 'heft start --clean',
+    'serve:gulp': 'gulp serve'
+  };
+
+  const packageJsonContent = await fsPromises.readFile(configPath, 'utf-8');
+  const packageJson = JSON.parse(packageJsonContent);
+
+  // Only add/overwrite scripts if force is true, otherwise do not overwrite existing matching scripts
+  packageJson.scripts = packageJson.scripts || {};
+  for (const [key, value] of Object.entries(defaultScripts)) {
+    if (force || !(key in packageJson.scripts)) {
+      packageJson.scripts[key] = value;
     }
-    return undefined;
-  } catch (err) {
-    // File does not exist or cannot be read
-    return undefined;
   }
+
+  await fsPromises.writeFile(configPath, JSON.stringify(packageJson, null, 2), 'utf-8');
 }
 
-export async function addScriptNameRunType(scriptName: string, value: any): Promise<void> {
-  const { configDir, configPath } = getConfigPaths();
-  let config = {};
+export const installHeftDotenvPlugin = async () => {
+  if (await isUsingGulp()) {
+    logger.error('Heft .env plugin can only be installed in projects using Heft, but Gulp was detected.');
+    return;
+  }
+
+  const spawn = require('child_process').spawnSync;
+  const result = spawn('npm', ['install', '--save-dev', '@mschauer5/heft-dotenv-plugin'], {
+    stdio: 'inherit',
+    shell: true
+  });
+  if (result.error) {
+    logger.error(`Error installing @mschauer5/heft-dotenv-plugin: ${result.error.message}`);
+    return;
+  }
+
+  // Modify heft.json to include the dotenv plugin
+  const heftConfigPath = path.join(process.cwd(), 'heft.json');
+  let heftConfig: any = {};
   try {
-    const data = await fsPromises.readFile(configPath, 'utf-8');
-    config = JSON.parse(data);
+    const heftConfigContent = await fsPromises.readFile(heftConfigPath, 'utf-8');
+    heftConfig = JSON.parse(heftConfigContent);
   } catch (err) {
-    // File does not exist or is invalid, start with empty config
+    logger.error(`Error reading heft.json: ${err.message}`);
+    return;
   }
-  config[scriptName] = value;
-  await fsPromises.mkdir(configDir, { recursive: true });
-  await fsPromises.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
-}
+  heftConfig.heftPlugins = heftConfig.heftPlugins || [];
+  if (!heftConfig.heftPlugins.some((plugin: any) => plugin.pluginPackage === '@mschauer5/heft-dotenv-plugin')) {
+    heftConfig.heftPlugins.push({ pluginPackage: '@mschauer5/heft-dotenv-plugin' });
+    await fsPromises.writeFile(heftConfigPath, JSON.stringify(heftConfig, null, 2), 'utf-8');
+    logger.success('Added @mschauer5/heft-dotenv-plugin to heft.json plugins.');
+  } else {
+    logger.info('@mschauer5/heft-dotenv-plugin is already included in heft.json plugins.');
+  }
+};

package/src/index.ts

@@ -3,7 +3,7 @@ import chalk from 'chalk';
 import * as commander from 'commander';
 import { Command } from 'commander';
 import * as commands from './commands';
-import { logger } from './common';
+import { logger, util } from './common';
 const program = new Command();
 
 const defaultToolkitName = 'spfx-toolkit';
@@ -12,7 +12,7 @@ program
   .name('Matt Schauer SPFx Toolkit')
   .description('CLI to help with SPFx development')
   .addHelpText('beforeAll', chalk.blueBright('Developed by Matt Schauer'))
-  .version('1.0.10');
+  .version('1.0.11');
 
 program
   .command('add-alias')
@@ -24,7 +24,7 @@ program
 
 program
   .command('clear-alias')
-  .description('remove alias for spfx-toolkit')
+  .description('remove any alias for spfx-toolkit')
   .action(() => {
     commands.alias.clearAlias(defaultToolkitName);
   });
@@ -33,43 +33,77 @@ program
   .command('serve')
   .description('Serve / Start the SPFx Project')
   .action(() => {
-    commands.serve.run();
+    commands.scripts.run('serve');
   });
 
 program
   .command('build')
   .description('Build Project')
-  .option('-p, --usepackage', "Use package.json script 'build' as the command")
-  .option('-d, --isdefault', 'Set current command as default build action')
-  .action((options) => {
-    let usePackage = false;
-    let isdefault = false;
-    if (options.isdefault) {
-      isdefault = true;
-    }
-    if (options.usepackage) {
-      usePackage = true;
-    }
-
-    commands.build.run(usePackage, isdefault);
+  .action(() => {
+    commands.scripts.run('build');
   });
 
 program
   .command('bundle')
   .description('Bundle Project')
-  .option('-p, --usepackage', "Use package.json script 'bundle' as the command")
-  .option('-d, --isdefault', 'Set current command as default bundle action')
-  .action((options) => {
-    let usePackage = false;
-    let isdefault = false;
-    if (options.isdefault) {
-      isdefault = true;
+  .option('-i, --increment <part>', 'Increment package version (major, minor, patch)', (value: string) => {
+    if (!['major', 'minor', 'patch'].includes(value)) {
+      throw new Error(`Invalid increment part: ${value}.  Must be one of major, minor, or patch.`);
     }
-    if (options.usepackage) {
-      usePackage = true;
+    return value; // Return the validated value
+  })
+  .action((options) => {
+    commands.scripts.run('bundle', options.increment);
+  });
+
+program
+  .command('run')
+  .description('Run a script from package.json by name')
+  .addArgument(new commander.Argument('<name>', 'script name to run from package.json'))
+  .action((name) => {
+    commands.scripts.run(name);
+  });
+
+program
+  .command('open-global-config')
+  .description('Open global package.json for spfx-toolkit')
+  .action(() => {
+    util.openGlobalPackageJsonInEditor();
+  });
+
+program
+  .command('global-config-init')
+  .description('Set default scripts in global package.json for spfx-toolkit')
+  .option('-f, --force', 'If set will overwrite existing scripts names in global package.json')
+  .action((options) => {
+    util.initGlobalPackageJsonWithDefaults(options.force);
+  });
+
+program
+  .command('sync-script')
+  .description('Sync a script name from global or local package.json')
+  .addArgument(new commander.Argument('<name>', 'script name in package.json'))
+  .addArgument(new commander.Argument('<to>', 'global | local'))
+  .action((name, to) => {
+    if (to !== 'global' && to !== 'local') {
+      logger.error("Source must be either 'global' or 'local'.");
+      return;
     }
+    commands.scripts.sync(name, to);
+  });
+
+program
+  .command('open-solution')
+  .description('Open solution folder')
+  .action(() => {
+    commands.openSolution();
+  });
 
-    commands.bundle.run(usePackage, isdefault);
+program
+  .command('set-heft-dotenv-plugin')
+  .description('Installs and configures npm package that allows you to use .env files with Heft')
+  .action(() => {
+    util.installHeftDotenvPlugin();
   });
 
 program

package/src/commands/serve.command.ts

@@ -1,13 +0,0 @@
-import { logger, util } from '../common';
-
-export const run = async (): Promise<void> => {
-  logger.info('Starting the SPFx development server...');
-  util.isUsingGulp().then((usingGulp) => {
-    if (usingGulp) {
-      logger.info('Gulp detected. Running gulp serve...');
-    } else {
-      logger.error('Gulp not detected. Please ensure you have gulp installed and configured.');
-    }
-  });
-  // Implementation of the serve command goes here
-};