@genesislcap/build-kit 14.162.2-alpha-a2fd6f2.0 → 14.162.2

package/src/utils/proxy.ts

@@ -0,0 +1,139 @@
+import consola from 'consola';
+import type { ServerOptions } from 'http-proxy';
+import portfinderSync from 'portfinder-sync';
+
+/**
+ * @public
+ */
+export const getPort = (packageJson): number =>
+  portfinderSync.getPort(packageJson.config?.PORT || process.env.PORT || 9000);
+
+/**
+ * @public
+ */
+export const convertWsEndpointToHTTP = (endpoint = '', socketExt = '') => {
+  const protocolUpdate = endpoint.replace(/^ws(s)?:\/\//, 'http$1://');
+  return socketExt ? protocolUpdate.replace(`/${socketExt}`, '') : protocolUpdate;
+};
+
+/**
+ * Config to create a development proxy for a specific path.
+ *
+ * @public
+ */
+export type DevProxyConfig = {
+  target?: string;
+  path?: string;
+  options?: ServerOptions;
+};
+
+/**
+ * Config to create development proxies for an array of paths.
+ *
+ * @public
+ */
+export type DevProxiesConfig = Omit<DevProxyConfig, 'path'> & {
+  paths?: string[];
+};
+
+/**
+ * Object containing entries for each proxy keyed by path.
+ *
+ * @public
+ */
+export type DevProxies = Record<string, ServerOptions> & {};
+
+/**
+ * Create development proxy for a specific path.
+ *
+ * @example
+ * ```ts
+ * const proxy = createDevProxy({ path: '/sm', target: process.env.API_HOST, options: {...} });
+ * ```
+ *
+ * @remarks
+ * Applicable when running in dev mode and a valid target and path is set.
+ *
+ * @privateRemarks
+ * It is important to guard for the case where neither target nor path is set by returning undefined.
+ * Proxies with empty string targets will cause blow ups in vite, whereas webpack seems to tolerate them.
+ *
+ * @param config - A {@link DevProxyConfig}.
+ * @returns A {@link DevProxies} object or undefined.
+ *
+ * @public
+ */
+export const createDevProxy = (config: DevProxyConfig): DevProxies | undefined => {
+  if (!config.target || !config.path) {
+    return undefined;
+  }
+  const { options, path, target } = config;
+  return {
+    [path]: {
+      target,
+      secure: false,
+      changeOrigin: true,
+      cookieDomainRewrite: 'localhost',
+      ws: true,
+      ...(options ?? {}),
+      headers: {
+        origin: target,
+        ...(options?.headers ?? {}),
+      },
+    },
+  };
+};
+
+/**
+ * Create development proxies for an array of paths.
+ *
+ * @example Create default development proxies
+ * ```ts
+ * const proxy = createDevProxies();
+ * ```
+ *
+ * @example Create custom development proxies
+ * ```ts
+ * const proxy = createDevProxies({ paths: ['/foo', '/bar'], target: 'http://mydomain.com' });
+ * ```
+ *
+ * @remarks
+ * `process.env.API_HOST` will be used as the target if `config.target` is not set. Undefined will be returned if
+ * neither are available.
+ *
+ * @privateRemarks
+ * It is important to guard for the case where neither target nor API_HOST are set by returning undefined.
+ * Proxies with empty string targets will cause blow ups in vite, whereas webpack seems to tolerate them.
+ *
+ * @param config - An optional {@link DevProxiesConfig}.
+ * @returns A {@link DevProxies} object or undefined.
+ *
+ * @public
+ */
+export const createDevProxies = (config: DevProxiesConfig = {}): DevProxies | undefined => {
+  if (!config.target && !process.env.API_HOST) {
+    return undefined;
+  }
+  const socketExt = process.env.SOCKET_EXT || 'gwf';
+  const paths = Array.isArray(config.paths) ? config.paths : ['/sm', '/sso', `/${socketExt}`];
+  const target = config.target ?? convertWsEndpointToHTTP(process.env.API_HOST, socketExt);
+  const defaultConfig: DevProxyConfig = {
+    ...config,
+    target,
+  };
+  const proxies = paths.reduce(
+    (prev, curr) => ({
+      ...prev,
+      ...createDevProxy({
+        ...defaultConfig,
+        path: curr,
+      }),
+    }),
+    {},
+  );
+  if (Object.keys(proxies).length) {
+    consola.info('Dev Proxies:');
+    console.table(proxies);
+  }
+  return proxies;
+};

package/src/utils/seed.fetching.ts

@@ -0,0 +1,257 @@
+import { cpSync, existsSync, mkdirSync } from 'node:fs';
+import { relative, sep } from 'node:path';
+import { consola } from 'consola';
+import getNpmTarballUrl from 'get-npm-tarball-url';
+import { downloadTemplate } from 'giget';
+import type { PackageJson } from 'pkg-types';
+import { downloadTarball } from './archive';
+import { bold } from './console';
+import { rm } from './fs';
+import { getLatestVersion } from './npm';
+import { loadGenxModule } from './seed.meta';
+import { removeExclusions } from './seed.processing';
+
+export type LocalFetchResult = {
+  local: boolean;
+  genxDir: string;
+  seed: string;
+  subdir: string; // seed subdir within seed repo (if set)
+  pkg: PackageJson;
+  dir: string; // app directory e.g. myapp
+  extractedSeedDir: string; // directory to extract seed: for init operation same as dir, for add operaion dir/.genx/tmp
+  extractedSeedGenxDir: string;
+};
+
+export type RemoteGitFetchResult = {
+  repo: string;
+  ref: string;
+  id: string;
+};
+
+export type RemoteNPMFetchResult = {
+  artifact: string;
+  ref: string;
+};
+
+export type RemoteFetchResult = RemoteGitFetchResult | RemoteNPMFetchResult;
+
+export type FetchResult = LocalFetchResult | (LocalFetchResult & RemoteFetchResult);
+
+export const resolveGitSeed = (
+  seed = '',
+  ref = 'main',
+  subdir = '',
+  provider = 'gh',
+): RemoteGitFetchResult => {
+  const parts = seed.split('/');
+  const repo = parts.pop() || 'blank-app-seed';
+  const user = parts.pop() || 'genesiscommunitysuccess';
+  const dir = subdir ? `/${subdir}` : '';
+  return {
+    repo: `${user}/${repo}`,
+    ref,
+    // Giget-compatible template ID
+    id: `${provider}:${user}/${repo}${dir}#${ref}`,
+  };
+};
+
+export const resolveNPMSeed = (
+  seed = '',
+  ref = 'latest',
+  useDefaultNPMScope = true,
+): RemoteNPMFetchResult => {
+  const parts = seed.split('/');
+  const moduleName = parts.pop() || 'blank-app-seed';
+  const scope = parts.pop() || (useDefaultNPMScope ? 'genesislcap' : '');
+  const scopeFormatted = scope ? `@${scope}/` : '';
+  const artifact = `${scopeFormatted}${moduleName}`;
+  return {
+    artifact,
+    ref,
+  };
+};
+
+export type SeedDirs = {
+  isLocalSeed: boolean;
+  dir: string;
+  subdir: string;
+  localPath: string;
+  genxDir: string;
+  extractedSeedDir: string;
+  extractedSeedGenxDir: string;
+};
+
+export const getSeedDirs = (
+  seed: string,
+  dir: string,
+  subdir: string,
+  isInit: boolean,
+  remote: boolean,
+): SeedDirs => {
+  const GENX_DIR = '/.genx';
+  const TMP_DIR = '/tmp';
+  const localPath = subdir ? `${seed}/${subdir}` : seed;
+  const isLocalSeed = !remote && existsSync(localPath);
+  const genxDir = relative(process.cwd(), `${dir}${GENX_DIR}`);
+  const extractedSeedDir = isInit ? dir : relative(process.cwd(), `${dir}${GENX_DIR}${TMP_DIR}`);
+  const extractedSeedGenxDir = isInit
+    ? genxDir
+    : relative(process.cwd(), `${extractedSeedDir}${GENX_DIR}`);
+  return {
+    localPath,
+    dir,
+    subdir,
+    isLocalSeed,
+    genxDir,
+    extractedSeedDir,
+    extractedSeedGenxDir,
+  };
+};
+
+const copyLocalSeed = (dirs: SeedDirs, ref: string, start: number): LocalFetchResult => {
+  const { dir, subdir, localPath, extractedSeedDir, genxDir, extractedSeedGenxDir } = dirs;
+  consola.info(`Copying local seed ${bold(localPath)}`);
+  try {
+    if (ref) {
+      consola.warn(`${bold('ref')} has no effect when used with a local seed`);
+    }
+    cpSync(localPath, extractedSeedDir, { recursive: true });
+    consola.success(`Seed copied in ${Date.now() - start}ms`);
+    return {
+      local: true,
+      genxDir,
+      seed: localPath,
+      subdir,
+      pkg: loadGenxModule(extractedSeedGenxDir),
+      dir,
+      extractedSeedDir,
+      extractedSeedGenxDir,
+    };
+  } catch (e) {
+    consola.error(`Error copying ${localPath} to ${bold(dir)}`, e);
+    process.exit(1);
+  }
+};
+
+const fetchNPMSeed = async (
+  seed: string,
+  ref: string,
+  dirs: SeedDirs,
+  useDefaultNPMScope: boolean,
+  start: number,
+) => {
+  let success = true;
+  const data = resolveNPMSeed(seed, ref, useDefaultNPMScope);
+
+  consola.info(
+    `Downloading NPM seed ${bold(data.artifact)} (dist tag ${bold(data.ref)}, subdir: ${bold(
+      dirs.subdir || 'N/A',
+    )}) to ${bold(dirs.dir)} directory...`,
+  );
+
+  try {
+    const version = getLatestVersion(data.artifact, data.ref, false);
+    const url = getNpmTarballUrl(data.artifact, version);
+    // NPM tarballs contains top-level directory called package
+    const path = dirs.subdir ? `${sep}package/${dirs.subdir}` : `${sep}package`;
+    await downloadTarball(url, dirs.extractedSeedDir, path).catch((err) => {
+      consola.warn('Error downloading module', err);
+      success = false;
+    });
+  } catch (err) {
+    success = false;
+    consola.warn('Error fetching version information from the registry');
+  }
+
+  // If NPM download successful return result, otherwise fall back to Git download
+  if (success) {
+    consola.success(`Seed downloaded in ${Date.now() - start}ms`);
+
+    return {
+      local: false,
+      genxDir: dirs.genxDir,
+      seed,
+      subdir: dirs.subdir,
+      pkg: loadGenxModule(dirs.extractedSeedGenxDir),
+      dir: dirs.dir,
+      extractedSeedDir: dirs.extractedSeedDir,
+      extractedSeedGenxDir: dirs.extractedSeedGenxDir,
+      ...data,
+    };
+  }
+};
+
+const fetchGitSeed = async (seed: string, ref: string, dirs: SeedDirs, start: number) => {
+  const data = resolveGitSeed(seed, ref, dirs.subdir);
+  consola.info(
+    `Downloading Git seed ${bold(data.repo)} (Ref ${bold(data.ref)}, subdir: ${bold(
+      dirs.subdir || 'N/A',
+    )}) to ${bold(dirs.dir)} directory...`,
+  );
+  try {
+    await downloadTemplate(data.id, {
+      dir: dirs.extractedSeedDir, // destination directory to clone to
+      // auth?: string; // custom Authorization token to use for downloading template
+      registry: false, // disable built-in Giget registry
+    });
+    consola.success(`Seed downloaded in ${Date.now() - start}ms`);
+    return {
+      local: false,
+      genxDir: dirs.genxDir,
+      seed,
+      subdir: dirs.subdir,
+      pkg: loadGenxModule(dirs.extractedSeedGenxDir),
+      dir: dirs.dir,
+      extractedSeedDir: dirs.extractedSeedDir,
+      extractedSeedGenxDir: dirs.extractedSeedGenxDir,
+      ...data,
+    };
+  } catch (err) {
+    const error = process.env.DEBUG ? err : err.message;
+    consola.error(error);
+    process.exit(1);
+  }
+};
+
+// download remote or copy local seed
+export const fetchSeed = async (
+  seed: string,
+  dir: string,
+  remote: boolean,
+  ref: string,
+  insecure: boolean,
+  subdir: string,
+  isInit: boolean,
+  lookupInNPM: boolean,
+  useDefaultNPMScope: boolean,
+): Promise<FetchResult> => {
+  // disable SSL cert verification
+  if (insecure) {
+    process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+  }
+
+  const start = Date.now();
+  const dirs = getSeedDirs(seed, dir, subdir, isInit, remote);
+
+  if (!isInit) {
+    await rm(dirs.extractedSeedDir);
+    mkdirSync(dirs.extractedSeedDir);
+  }
+
+  let result: FetchResult;
+  if (dirs.isLocalSeed) {
+    result = copyLocalSeed(dirs, ref, start);
+  } else {
+    if (lookupInNPM) {
+      result = await fetchNPMSeed(seed, ref, dirs, useDefaultNPMScope, start);
+    }
+    // if NPM lookup disabled or if it's enabled & failed, fall back to Git
+    if (!lookupInNPM || !result) {
+      result = await fetchGitSeed(seed, ref, dirs, start);
+    }
+  }
+
+  await removeExclusions(dirs.extractedSeedDir, result.pkg.genxSeedConfig?.exclude);
+
+  return result;
+};

package/src/utils/seed.meta.ts

@@ -0,0 +1,34 @@
+import { resolve } from 'node:path';
+import { consola } from 'consola';
+import { getPromptDefaults, getPromptValidators, validateSeedData } from './prompts';
+
+// load seed details including prompt question defaults and validators
+export const loadSeed = async (dir) => {
+  const GENX_RC = '.genxrc.js';
+  const genxConfigPath = resolve(dir, GENX_RC);
+  const { prompts, configure, details } = require(genxConfigPath);
+
+  const defaults = await getPromptDefaults(prompts());
+  const validators = await getPromptValidators(prompts());
+  const validate = (data) => validateSeedData(data, validators);
+  return {
+    prompts: prompts(),
+    configure: configure(),
+    details: details(),
+    defaults,
+    validators,
+    validate,
+  };
+};
+
+export const loadGenxModule = (genxDir: string, module = 'package.json', warnIfMissing = true) => {
+  const path = resolve(genxDir, module);
+  try {
+    return require(path);
+  } catch (e) {
+    if (warnIfMissing) {
+      consola.warn(`Could not load ${module} from ${genxDir}`);
+    }
+    return {};
+  }
+};

package/src/utils/seed.processing.ts

@@ -0,0 +1,100 @@
+import { existsSync, renameSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { consola } from 'consola';
+import { bold } from './console';
+import { listAllFiles, rm } from './fs';
+import type { fsEntry } from './fs';
+import { render, renderFile } from './handlebars';
+import { writeJSON } from './json';
+
+export const PROMPT_DATA_FILE = 'answers.json';
+
+export const removeExclusions = async (dir, exclusions: string[]) => {
+  try {
+    const exclude = (exclusions ?? []).map((x) => resolve(dir, x));
+    await Promise.all(
+      exclude.map(async (exclusion) => {
+        if (existsSync(exclusion)) {
+          await rm(exclusion);
+          consola.debug(`Excluded: ${exclusion}`);
+        } else {
+          consola.debug(`Ignored invalid exclusion: ${exclusion}`);
+        }
+      }),
+    );
+  } catch (err) {
+    const error = process.env.DEBUG ? err : err.message;
+    consola.error(error);
+    process.exit(1);
+  }
+};
+
+const processItem = (
+  { base, dir: itemDir, path, isDir, ext, stats }: fsEntry,
+  data,
+  renamingEnabled: boolean,
+  interpolationEnabled: boolean,
+  interpolationWhitelist: string[],
+) => {
+  const baseNew = render(base, data);
+  const needsRenaming = renamingEnabled && baseNew !== base;
+  const pathNew = needsRenaming ? resolve(itemDir, baseNew) : path;
+
+  if (needsRenaming) {
+    try {
+      renameSync(resolve(itemDir, base), resolve(itemDir, baseNew));
+      consola.debug(`Renamed ${bold(base)} to ${bold(baseNew)}`);
+    } catch (e) {
+      consola.error(`Error renaming ${bold(base)} to ${bold(baseNew)}`);
+    }
+  }
+
+  // Handlebars rendering
+  if (interpolationEnabled && !isDir && interpolationWhitelist.some((i) => baseNew.includes(i))) {
+    try {
+      renderFile(pathNew, data, pathNew);
+      consola.debug(`Interpolated variables in ${pathNew}`);
+    } catch (e) {
+      consola.error(`Error interpolating variables in ${pathNew}`);
+    }
+  }
+
+  return { isDir, ext, dir: itemDir, base: baseNew, path: pathNew, stats };
+};
+
+export const processOptions = (fetchSeedResult, dir, data, isInit, persistedAnswers) => {
+  const options = fetchSeedResult.pkg?.genxSeedConfig || {};
+  consola.debug('Seed options', JSON.stringify(options));
+
+  if (options.processFiles) {
+    const ignoreDirs = options.processFiles?.exclude || [
+      '.git',
+      '.genx',
+      '.github',
+      'node_modules',
+      '.gradle',
+      'gradle',
+    ];
+
+    const filter = (entry: fsEntry) => !ignoreDirs.includes(entry.base);
+    const mapper = (entry: fsEntry) =>
+      processItem(
+        entry,
+        data,
+        !!options.processFiles?.rename,
+        !!options.processFiles?.interpolateVariables?.enabled,
+        options.processFiles?.interpolateVariables?.include,
+      );
+
+    listAllFiles(dir, filter, mapper);
+  }
+
+  if (options.persistAnswers) {
+    const jsonPath = resolve(fetchSeedResult.genxDir, PROMPT_DATA_FILE);
+    const additions = persistedAnswers.additions || [];
+    const json = isInit
+      ? data
+      : { ...data, appSeed: persistedAnswers.appSeed, additions: [...additions, data.appSeed] };
+    writeJSON(jsonPath, json);
+  }
+};

package/src/utils/seed.setup.ts

@@ -0,0 +1,101 @@
+import { cpSync } from 'node:fs';
+import { resolve } from 'node:path';
+import * as changeCase from 'change-case';
+import { consola } from 'consola';
+import { runAsync } from './child-process';
+import { listAllFiles, rename, rm } from './fs';
+import { registerPartial, renderFile } from './handlebars';
+import { editJSONFile } from './json';
+import { replaceObjectKeys } from './object';
+import { getData } from './prompts';
+import { loadGenxModule } from './seed.meta';
+import { PROMPT_DATA_FILE, processOptions } from './seed.processing';
+
+export const installSeedDeps = async (dir, isLogLevelVerbose) => {
+  let dependencies = {};
+  try {
+    const packageJSONPath = resolve(dir, 'package.json');
+    const packageJSON = require(packageJSONPath);
+    dependencies = packageJSON.dependencies || {};
+  } catch (e) {}
+
+  consola.debug('Seed NPM dependencies', {
+    targetInstallDir: dir,
+    dependencyCount: Object.keys(dependencies).length,
+  });
+
+  if (Object.keys(dependencies).length !== 0) {
+    const start2 = Date.now();
+    consola.info('Installing seed NPM dependencies...');
+    await runAsync(dir, 'npm install', {
+      prefixCommandWithNode: false,
+      exitOnError: false,
+      verbose: isLogLevelVerbose,
+      env: {
+        ...process.env,
+        NODE_ENV: 'production', // only install production NPM dependencies
+      },
+    }).catch((err) => {
+      consola.error(
+        'Unexpected error installing seed dependencies. Try re-runing with --log-level verbose',
+      );
+      if (err) {
+        consola.error(err);
+      }
+      process.exit(1);
+    });
+    consola.success(`Installed in ${Date.now() - start2}ms`);
+  }
+};
+
+// run seed configure script
+export const configureSeedApp = async (
+  seedInfo,
+  fetchSeedResult,
+  params,
+  dir,
+  skipOptionalPrompts,
+  isInit: boolean,
+) => {
+  const { configure, prompts, details, defaults, validate } = seedInfo;
+
+  // load persisted answers if available
+  const persistedAnswers = loadGenxModule(fetchSeedResult.genxDir, PROMPT_DATA_FILE, false);
+
+  // get prompt answers
+  const data = await getData(
+    persistedAnswers,
+    prompts,
+    details,
+    defaults,
+    validate,
+    params,
+    dir,
+    skipOptionalPrompts,
+    fetchSeedResult,
+  );
+  consola.debug('Loaded seed data', data);
+
+  const utils = {
+    writeFileWithData: renderFile,
+    registerPartial,
+    editJSONFile,
+    replaceObjectKeys,
+    listAllFiles,
+    rename,
+    changeCase,
+  };
+
+  // run seed configure script
+  await configure(data, utils).catch((e) => consola.error(e));
+
+  // process seed exclusions, render templates, rename files/folders
+  processOptions(fetchSeedResult, fetchSeedResult.extractedSeedDir, data, isInit, persistedAnswers);
+
+  // when adding seed, copy result from temp folder to the app root (omitting .genx folder of the seed)
+  if (!isInit) {
+    await rm(fetchSeedResult.extractedSeedGenxDir);
+    cpSync(fetchSeedResult.extractedSeedDir, dir, { recursive: true });
+    await rm(fetchSeedResult.extractedSeedDir);
+  }
+};

package/src/utils/time.ts

@@ -0,0 +1 @@
+export { default as ms } from 'pretty-ms';

package/test/utils/args.test.ts

@@ -0,0 +1,17 @@
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+import { unparseArgs } from '../../src/utils';
+
+const suite = createLogicSuite('args utils');
+
+suite('unparseArgs', () => {
+  const args = {
+    '--': [],
+    str: 'bar',
+    b1: true,
+    b2: false,
+    arr: ['a', 'b'],
+  };
+  assert.is(unparseArgs(args), '--str bar --b1 --no-b2 --arr a b');
+});
+
+suite.run();