@genesislcap/build-kit 14.162.4 → 14.162.5

package/src/utils/prompts.ts

@@ -1,160 +0,0 @@
-import { basename } from 'node:path';
-import consola from 'consola';
-import inquirer from 'inquirer';
-import type { Question } from 'inquirer';
-import { bold } from './console';
-
-export const runPrompts = async (prompts: any, prevAns: any = {}) => prompts(inquirer, prevAns);
-
-export const validateSeedData = (data, validators) => {
-  const errors = [];
-
-  Object.keys(data).forEach((key) => {
-    const value = data[key];
-    if (typeof value === 'undefined') {
-      errors.push({ message: `${key} is undefined` });
-    } else if (value === '') {
-      errors.push({ message: `${key} is empty` });
-    } else if (validators[key]) {
-      const isValid = validators[key](value);
-      if (isValid !== true) {
-        errors.push({ message: `${key} is invalid: ${bold(value)} ${isValid}` });
-      }
-    }
-  });
-
-  return errors;
-};
-
-const getPromptInputs = async (prompts): Promise<Question[]> => {
-  // disable any prompt messages
-  const _log = console.log;
-  console.log = () => {};
-
-  const inputs = [];
-
-  const mockInquirer = {
-    prompt: async (promptInputs) => {
-      inputs.push(...promptInputs);
-      return {};
-    },
-  };
-
-  await prompts(mockInquirer);
-
-  // re-enable prompt messages
-  console.log = _log;
-
-  return inputs;
-};
-
-export const getPromptDefaults = async (prompts) => {
-  const inputs = await getPromptInputs(prompts);
-
-  const defaults = inputs.reduce((acc, value) => {
-    let addDefault;
-    if (typeof value.when === 'function') {
-      addDefault = value.when(acc);
-    } else if (typeof value.when === 'undefined') {
-      addDefault = true;
-    } else {
-      addDefault = value.when;
-    }
-
-    if (addDefault) {
-      acc[value.name] = value.default;
-    }
-
-    return acc;
-  }, {});
-
-  return defaults;
-};
-
-export const getPromptValidators = async (prompts) => {
-  const inputs = await getPromptInputs(prompts);
-
-  const validators = inputs.reduce((acc, value) => {
-    acc[value.name] = value.validate;
-    return acc;
-  }, {});
-
-  return validators;
-};
-
-// process CLI prompt params
-const getCLIParams = (
-  persistedAnswers,
-  params,
-  defaults,
-  dir,
-  subdir,
-  skipOptionalPrompts,
-  seedMeta,
-  details,
-  validate,
-) => {
-  const base = skipOptionalPrompts ? defaults : {};
-
-  const cliParams = {
-    ...base,
-    ...persistedAnswers,
-    ...params,
-    appName: basename(dir),
-    pkgName: basename(dir),
-    directory: basename(dir),
-    appSeed: {
-      type: seedMeta.local ? 'local' : 'remote',
-      name: seedMeta.seed,
-      description: details.description,
-      version: details.version,
-      repo: seedMeta.repo,
-      artifact: seedMeta.artifact,
-      ref: seedMeta.ref,
-      subdir: seedMeta.subdir,
-      date: new Date(),
-    },
-  };
-  const validationErrors = validate(cliParams);
-  if (validationErrors.length) {
-    consola.error('Validation errors detected:');
-    validationErrors.forEach((error) => consola.log(`  * ${error.message}`));
-    process.exit(1);
-  }
-
-  return cliParams;
-};
-
-// get combined prompt answers (CLI params / defaults / user interaction)
-export const getData = async (
-  persistedAnswers,
-  prompts,
-  details,
-  defaults,
-  validate,
-  params,
-  dir,
-  skipOptionalPrompts,
-  seedMeta,
-) => {
-  // process CLI params
-  const cliParams = getCLIParams(
-    persistedAnswers,
-    params,
-    defaults,
-    dir,
-    seedMeta.subdir,
-    skipOptionalPrompts,
-    seedMeta,
-    details,
-    validate,
-  );
-
-  const data = await runPrompts(prompts, cliParams);
-
-  const combined = {
-    ...cliParams,
-    ...data,
-  };
-  return combined;
-};

package/src/utils/proxy.ts

@@ -1,139 +0,0 @@
-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

@@ -1,257 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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);
-  }
-};