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

package/src/utils/config.ts

@@ -0,0 +1,45 @@
+import defu from 'defu';
+import type { PackageJson } from 'pkg-types';
+import { resolveFederationConfig, getFederatedPkgName } from './federation';
+import { tryRequire } from './npm';
+
+const getDefaultConfig = (packageName) => ({
+  app: {},
+  builder: {
+    default: 'webpack',
+    dev: 'vite',
+    lint: 'eslint-stylelint',
+    test: 'uvu-playwright',
+  },
+  clean: !process.env.GENX_NO_CLEAN,
+  copyAssets: ['**/*.{css,jpg,png,svg,mp4,ogg,webm}'],
+  env: [
+    'API_HOST',
+    'DEFAULT_ORGANISATION',
+    'DEFAULT_USER',
+    'DEFAULT_PASSWORD',
+    'ENABLE_SSO',
+    'GENX.*',
+    'GENX_*',
+    'FORCE_HTTP',
+    'SOCKET_EXT',
+  ],
+  federation: {
+    name: getFederatedPkgName(packageName),
+  },
+});
+
+const readConfig = (packageJSON: PackageJson, path = './genx.config') => {
+  const genxConfig = tryRequire(path) || {};
+  const packageJSONConfig = packageJSON.genx || {};
+  const defaultConfig = getDefaultConfig(packageJSON.name);
+  return defu(genxConfig, packageJSONConfig, defaultConfig);
+};
+
+export const loadConfig = async (packageJSON: PackageJson) => {
+  const config = readConfig(packageJSON);
+  return {
+    ...config,
+    federation: await resolveFederationConfig(config.federation, packageJSON),
+  };
+};

package/src/utils/console.ts

@@ -0,0 +1 @@
+export { bold, dim, green, blue, white, yellow, grey, italic } from 'chalk';

package/src/utils/env.ts

@@ -0,0 +1,71 @@
+import consola from 'consola';
+import type { BuildContext, ENV } from '../types';
+
+export const setNodeEnv = (targetEnv: ENV) => {
+  const currentEnv = process.env.NODE_ENV;
+  if (currentEnv && currentEnv !== targetEnv) {
+    consola.warn(`Changing \`NODE_ENV\` from \`${currentEnv}\` to \`${targetEnv}\`.`);
+  }
+
+  process.env.NODE_ENV = targetEnv;
+};
+
+const resolveEnvValue = (ctx: BuildContext, key: string, value: string) => {
+  // `-e `FOO` case
+  // 1. check package.json config
+  // 2. fall back to a truthy value (shortcut for setting env var flags where exact value isn't important as long as it's truthy e.g. -e CI)
+  // we don't check process.env because there it'd mean setting env variable to the same value it already has
+  if (!value) {
+    return ctx.pkg.config && ctx.pkg.config[key] !== undefined ? ctx.pkg.config[key] : '1';
+  }
+
+  // `-e FOO=ABC` case
+  // 1. check package.json config
+  if (ctx.pkg.config && ctx.pkg.config[value] !== undefined) {
+    return ctx.pkg.config[value];
+  }
+
+  // 2. check process.env
+  if (process.env[value] !== undefined) {
+    return process.env[value];
+  }
+
+  // 3. fall back to provided value
+  return value;
+};
+
+export const setEnvVars = (ctx: BuildContext) => {
+  const { env = '' } = ctx.cli.options;
+  const envCombined = Array.isArray(env) ? env.join(',') : env;
+  const vars = envCombined.split(',');
+  vars.forEach((v) => {
+    const [keyRaw, valueRaw] = v.split('=');
+    const key = (keyRaw || '').trim();
+    const value = (valueRaw || '').trim();
+    if (key) {
+      const resolved = resolveEnvValue(ctx, key, value);
+      consola.info(`Setting \`${key}\` env variable to \`${resolved}\`.`);
+      process.env[key] = resolved;
+    }
+  });
+};
+
+// Given env variable name patterns and HTTP config, return a define plugin config
+export const resolveDefineConfig = (
+  patterns: string[],
+  httpConfig?: object,
+  builder?: 'webpack' | 'vite',
+): Record<string, string> =>
+  Object.entries(process.env)
+    .filter(([key]) => patterns.some((pattern) => key.match(pattern)))
+    .reduce(
+      (acc, [key, value]) => {
+        acc[key] = JSON.stringify(value);
+        return acc;
+      },
+      {
+        NODE_ENV: JSON.stringify(process.env.NODE_ENV),
+        HTTP_CONFIG: JSON.stringify(httpConfig || ''),
+        BUILDER: JSON.stringify(builder ?? ''),
+      },
+    );

package/src/utils/federation.ts

@@ -0,0 +1,40 @@
+import { camelCase } from 'change-case';
+import type { PackageJson } from 'pkg-types';
+import { loadPackageJSONFiles } from './npm';
+
+export const getFederatedPkgName = (pkgName = '') => camelCase(pkgName.split('/').pop());
+
+const getRemoteEntry = (name, port, host = 'localhost') =>
+  `${name}@http://${host}:${port}/remoteEntry.js`;
+
+const resolveFederatedRemotes = async (packages = []) => {
+  const packageJSONFiles = await loadPackageJSONFiles(packages);
+  return (await Promise.all(packageJSONFiles)).reduce((acc, packageJSON) => {
+    const name = getFederatedPkgName(packageJSON.name);
+    const port = packageJSON.config?.PORT;
+    acc[name] = getRemoteEntry(name, port);
+    return acc;
+  }, {});
+};
+
+const resolveSharedRemotes = (packages = [], packageJSON: PackageJson) =>
+  packages.reduce((acc, p) => {
+    acc[p] = {
+      singleton: true,
+      requiredVersion: packageJSON.dependencies[p],
+    };
+    return acc;
+  }, {});
+
+export const resolveFederationConfig = async (
+  federation = { remotes: [], shared: [] },
+  packageJSON: PackageJson,
+) => {
+  const remotes = await resolveFederatedRemotes(federation.remotes);
+  const shared = resolveSharedRemotes(federation.shared, packageJSON);
+  return {
+    ...federation,
+    remotes,
+    shared,
+  };
+};

package/src/utils/fs.ts

@@ -0,0 +1,53 @@
+import type { PathLike, Stats } from 'node:fs';
+import { readdirSync, statSync, renameSync } from 'node:fs';
+import { basename, dirname, extname, resolve } from 'node:path';
+import { rimraf } from 'rimraf';
+
+/**
+ * Deletes one or more provided paths
+ */
+export const rm = async (paths: string | string[]) =>
+  // We can add support for globbing or filtering in the future
+  // See https://github.com/isaacs/rimraf#rimraff-opts---promise for all options
+  rimraf(paths);
+
+export const rename = (oldPath: PathLike, newPath: PathLike) => renameSync(oldPath, newPath);
+
+export interface fsEntry {
+  path: string; // full path
+  base: string; // last portion of a path, similar to the Unix basename command
+  ext: string; // file extension, if present
+  dir: string; // directory name of a path, similar to the Unix dirname command
+  isDir: boolean; // whether entry is a directory
+  stats: Stats; // Stats object
+}
+
+export const listAllFiles = (
+  startPath,
+  filter = (item: fsEntry) => true,
+  mapper = (item: fsEntry): fsEntry => item,
+): string[] => {
+  const filenames = new Set<string>();
+  const walk = (dirPath) => {
+    const files = readdirSync(dirPath);
+    for (const file of files) {
+      const fullPath = resolve(dirPath, file);
+      const stats = statSync(fullPath);
+      const isDir = stats.isDirectory();
+      const base = basename(fullPath);
+      const ext = isDir ? null : extname(fullPath).toLowerCase();
+      const dir = dirname(fullPath);
+      const entry = mapper({ path: fullPath, isDir, base, ext, dir, stats });
+
+      if (filter(entry)) {
+        if (isDir) {
+          walk(entry.path);
+        } else {
+          filenames.add(entry.path);
+        }
+      }
+    }
+  };
+  walk(startPath);
+  return [...filenames];
+};

package/src/utils/handlebars.ts

@@ -0,0 +1,61 @@
+import { PathOrFileDescriptor, readFileSync, writeFileSync } from 'node:fs';
+import {
+  camelCase,
+  capitalCase,
+  constantCase,
+  dotCase,
+  paramCase,
+  pascalCase,
+  pathCase,
+  sentenceCase,
+  snakeCase,
+} from 'change-case';
+import handlebars from 'handlebars';
+
+/*
+| Method            | Result      |
+| ----------------- | ----------- |
+| `camelCase`       | `twoWords`  |
+| `capitalCase`     | `Two Words` |
+| `constantCase`    | `TWO_WORDS` |
+| `dotCase`         | `two.words` |
+| `kebabCase`       | `two-words` |
+| `lowerCase`       | `two words` |
+| `pascalCase`      | `TwoWords`  |
+| `pathCase`        | `two/words` |
+| `sentenceCase`    | `Two words` |
+| `snakeCase`       | `two_words` |
+| `upperCase`       | `TWO_WORDS` |
+*/
+
+handlebars.registerHelper('camelCase', (s) => s && camelCase(s));
+handlebars.registerHelper('capitalCase', (s) => s && capitalCase(s));
+handlebars.registerHelper('constantCase', (s) => s && constantCase(s));
+handlebars.registerHelper('dotCase', (s) => s && dotCase(s));
+handlebars.registerHelper('kebabCase', (s) => s && paramCase(s));
+handlebars.registerHelper('lowerCase', (s) => s && s.toLowerCase());
+handlebars.registerHelper('pascalCase', (s) => s && pascalCase(s));
+handlebars.registerHelper('pathCase', (s) => s && pathCase(s));
+handlebars.registerHelper('sentenceCase', (s) => s && sentenceCase(s));
+handlebars.registerHelper('snakeCase', (s) => s && snakeCase(s));
+handlebars.registerHelper('upperCase', (s) => s && s.toUpperCase());
+handlebars.registerHelper('ifEquals', (arg1, arg2, options) => {
+  return arg1 === arg2 ? options.fn(this) : options.inverse(this);
+});
+
+export const render = (template, data) => handlebars.compile(template)(data);
+
+export const renderFile = (
+  file: PathOrFileDescriptor,
+  data: object,
+  templateFile?: PathOrFileDescriptor,
+) => {
+  const template = readFileSync(templateFile || file, 'utf8');
+  const output = render(template, data);
+  writeFileSync(file, output, 'utf8');
+};
+
+export const registerPartial = (name: string, templateFile) => {
+  const template = readFileSync(templateFile, 'utf8');
+  handlebars.registerPartial(name, template);
+};

package/src/utils/https.ts

@@ -0,0 +1,29 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import consola from 'consola';
+
+/**
+ * @public
+ */
+export type DevCertOptions = {
+  cert: Buffer;
+  key: Buffer;
+};
+
+/**
+ * Get default dev cert options.
+ *
+ * @public
+ */
+export const getDevCertOptions = (): DevCertOptions | undefined => {
+  const certDir = resolve(__dirname, '../../cert/');
+  const cert = resolve(certDir, 'localhost.crt');
+  const key = resolve(certDir, 'localhost.key');
+  if (existsSync(cert) && existsSync(key)) {
+    return {
+      cert: readFileSync(cert),
+      key: readFileSync(key),
+    };
+  }
+  consola.warn(`Could not load the default development certificates from ${certDir}.`);
+};

package/src/utils/index.ts

@@ -0,0 +1,21 @@
+export * from './args';
+export * from './archive';
+export * from './build-context';
+export * from './child-process';
+export * from './config';
+export * from './console';
+export * from './env';
+export * from './federation';
+export * from './fs';
+export * from './handlebars';
+export * from './https';
+export * from './json';
+export * from './npm';
+export * from './prompts';
+export * from './proxy';
+export * from './object';
+export * from './seed.fetching';
+export * from './seed.meta';
+export * from './seed.processing';
+export * from './seed.setup';
+export * from './time';

package/src/utils/json.ts

@@ -0,0 +1,12 @@
+import { writeFileSync } from 'node:fs';
+import consola from 'consola';
+
+export { default as editJSONFile } from 'edit-json-file';
+
+export const writeJSON = (path, data) => {
+  try {
+    writeFileSync(path, JSON.stringify(data, null, 2));
+  } catch (e) {
+    consola.error(`Error writing to ${path}`);
+  }
+};

package/src/utils/npm.ts

@@ -0,0 +1,155 @@
+import { execSync } from 'node:child_process';
+import { writeFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import consola from 'consola';
+import jiti from 'jiti';
+import { readPackageJSON, resolvePackageJSON } from 'pkg-types';
+import type { PackageJson } from 'pkg-types';
+import type { BuildContext } from '../types';
+
+// Attempt to load id.{js,json,ts} file
+export const tryRequire = (id, rootDir = process.cwd()) => {
+  const _require = jiti(rootDir, { interopDefault: true, esmResolve: true });
+  try {
+    return _require(id);
+  } catch (error) {
+    if (error.code !== 'MODULE_NOT_FOUND') {
+      consola.error(`Error trying import ${id} from ${rootDir}`, error);
+    }
+    return null;
+  }
+};
+
+export const resolveBin = async (bin: string, module: string = bin) => {
+  const modulePath = require.resolve(module);
+  const dir = dirname(await resolvePackageJSON(modulePath));
+  const json = await readPackageJSON(modulePath);
+  const path = typeof json.bin === 'string' ? json.bin : (json.bin as Record<string, string>)[bin];
+  if (!path || !dir) {
+    throw new Error(`Could not resolve ${bin} / ${module}: ${dir} ${path}`);
+  }
+  return resolve(dir, path);
+};
+
+export const loadPackageJSON = async (dir?: string): Promise<PackageJson> => {
+  const pkg = (await readPackageJSON(dir)) || {};
+  const nameParts = (pkg.name || '').split('/');
+  // @scope/name -> name
+  // name -> name
+  pkg.nameUnscoped = nameParts.pop();
+  // @scope/name -> @scope
+  // name -> undefined
+  pkg.nameScope = nameParts.shift();
+  return pkg;
+};
+
+export const loadPackageJSONFiles = async (packages = []): Promise<PackageJson[]> =>
+  Promise.all(
+    packages.map((p) => {
+      const dir = dirname(require.resolve(p));
+      return loadPackageJSON(dir);
+    }),
+  );
+
+/*
+Given package name and range (e.g. '^14.0.1', '~14.0.1' or 'latest', return latest matching version)
+
+Registry response varies depending on whether a single or multiple versions are available.
+We return the single version which is the latest available.
+
+Response if a single version is available:
+'14.41.1'
+
+Response if multiple versions available:
+@genesislcap/genx@14.41.0 '14.41.0'
+@genesislcap/genx@14.41.1 '14.41.1'
+*/
+export const getLatestVersion = (name, range = 'latest', verbose = true) => {
+  let result;
+
+  try {
+    result = execSync(`npm info ${name}@${range} version`, {
+      stdio: ['pipe', 'pipe', 'ignore'],
+    })
+      .toString('utf8')
+      .trim()
+      .split('\n')
+      .pop()
+      .split(' ')
+      .pop()
+      .replace(/'/g, '');
+  } catch (e) {
+    if (verbose) {
+      consola.error(`Could not fetch ${name} version ${range} information from the registry`);
+    }
+  }
+
+  return result;
+};
+
+// given package version (^14.0.0, ~14.0.0), return range specifier (^, ~)
+export const getRangeSpecifier = (version) => {
+  const match = version.toString().match(/^[><=^~*]+/);
+  return (match && match[0]) || '';
+};
+
+// Return package.json without additional fields added by us
+export const getRawPkg = (ctx: BuildContext) => {
+  const { nameUnscoped, nameScope, ...pkg } = ctx.pkg;
+  return pkg;
+};
+
+export const updatePackageJSON = async (pkg: PackageJson) => {
+  const pkgJSONPath = await resolvePackageJSON();
+  try {
+    writeFileSync(pkgJSONPath, `${JSON.stringify(pkg, null, 2)}\n`);
+  } catch (e) {
+    consola.error(`Error updating package.json: ${pkgJSONPath}`, e);
+  }
+};
+
+const updateVersionType = (
+  deps: Record<string, string>,
+  newVersion: string,
+  exclude: string[],
+  include: string[] = ['@genesislcap'],
+): { name: string; to: string; from: string }[] => {
+  const updates = [];
+
+  Object.entries(deps || {}).forEach(([name, version = '']) => {
+    if (
+      include.some((pattern) => name.includes(pattern)) &&
+      exclude.every((pattern) => !name.includes(pattern))
+    ) {
+      const available = newVersion || getLatestVersion(name, version);
+      if (!available) {
+        return;
+      }
+      const rangeSpecifier = getRangeSpecifier(version);
+      const versionNew = `${rangeSpecifier}${available}`;
+
+      if (version !== versionNew) {
+        updates.push({
+          name,
+          from: version,
+          to: versionNew,
+        });
+        deps[name] = versionNew;
+      }
+    }
+  });
+
+  return updates;
+};
+
+export const updateVersions = (
+  pkg: PackageJson,
+  newVersion: string,
+  exclude: string[],
+  include: string[] = ['@genesislcap'],
+) => {
+  const deps = updateVersionType(pkg.dependencies, newVersion, exclude, include);
+  const devDeps = updateVersionType(pkg.devDependencies, newVersion, exclude, include);
+  const peerDeps = updateVersionType(pkg.peerDependencies, newVersion, exclude, include);
+  return [...deps, ...devDeps, ...peerDeps];
+};

package/src/utils/object.ts

@@ -0,0 +1,21 @@
+import { snakeCase } from 'change-case';
+
+export const objToSnakeCase = (obj: unknown) =>
+  Object.keys(obj).reduce((acc, key) => {
+    const keyRenamed = snakeCase(key);
+    acc[keyRenamed] = obj[key];
+    return acc;
+  }, {});
+
+export const replaceObjectKeys = (input, searchValue, replaceValue) =>
+  Object.fromEntries(
+    Object.entries(input).map(([key, value]) => [key.replace(searchValue, replaceValue), value]),
+  );
+
+export const excludeObjKeys = (obj: unknown, excludeKeys: string[]) =>
+  Object.keys(obj).reduce((acc, key) => {
+    if (!excludeKeys.includes(key)) {
+      acc[key] = obj[key];
+    }
+    return acc;
+  }, {});

package/src/utils/prompts.ts

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