@genesislcap/build-kit 14.142.1-alpha-2787e5d.0 → 14.143.0

package/src/utils/npm.ts

@@ -64,7 +64,7 @@ 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') => {
+export const getLatestVersion = (name, range = 'latest', verbose = true) => {
   let result;
 
   try {
@@ -79,7 +79,9 @@ export const getLatestVersion = (name, range = 'latest') => {
       .pop()
       .replace(/'/g, '');
   } catch (e) {
-    consola.error(`Could not fetch ${name} version ${range} information from the registry`);
+    if (verbose) {
+      consola.error(`Could not fetch ${name} version ${range} information from the registry`);
+    }
   }
 
   return result;

package/src/utils/prompts.ts

@@ -94,6 +94,7 @@ const getCLIParams = (
   validate,
 ) => {
   const base = skipOptionalPrompts ? defaults : {};
+
   const cliParams = {
     ...base,
     ...persistedAnswers,
@@ -104,11 +105,13 @@ const getCLIParams = (
     appSeed: {
       type: seedMeta.local ? 'local' : 'remote',
       name: seedMeta.seed,
-      about: details.description || '',
-      remoteUser: seedMeta.user,
-      remoteRepo: seedMeta.repo,
-      remoteBranch: seedMeta.ref,
-      subdir: seedMeta.subdir || '',
+      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);

package/src/utils/seed.fetching.ts

@@ -0,0 +1,256 @@
+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 module ${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
+    await downloadTarball(url, dirs.extractedSeedDir, `${sep}package`).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,98 @@
+import { cpSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { consola } from 'consola';
+import { runAsync } from './child-process';
+import { listAllFiles, rename, rm } from './fs';
+import { 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,
+    editJSONFile,
+    replaceObjectKeys,
+    listAllFiles,
+    rename,
+  };
+
+  // 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/test/fixtures/mock-seed/.genx/.genxrc.js

@@ -0,0 +1,7 @@
+module.exports = {
+  details: () => ({
+    nextStepsMessage: 'Thanks for installing mock seed'
+  }),
+  prompts: () => () => {},
+  configure: () => require('./configure'),
+};

package/test/fixtures/mock-seed/.genx/configure.js

@@ -0,0 +1,3 @@
+module.exports = async (data, utils) => {
+  console.log('configure script');
+};

package/test/fixtures/mock-seed/.genx/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "mock-seed",
+  "description": "Mock Seed",
+  "version": "1.0.0",
+  "license": "Apache-2.0",
+  "genxSeedConfig": {
+    "processFiles": {
+      "interpolateVariables": {
+        "enabled": true,
+        "include": [
+          ".kt",
+          ".md"
+        ]
+      }
+    }
+  }
+}

package/test/fixtures/mock-seed/test.md

@@ -0,0 +1,44 @@
+## Custom variable example
+
+* Random: {{random}}
+* Date: {{date}}
+
+## Env variable / conditional rendering example
+
+{{#if foo}}
+Env variable **FOO** set to true.
+{{else}}
+Env variable **FOO** set to false.
+{{/if}}
+
+https://handlebarsjs.com/examples/builtin-helper-ifelse-block.html
+
+{{#unless foo}}
+Env variable **FOO** wasn't set.
+{{/unless}}
+
+https://handlebarsjs.com/examples/builtin-helper-unless-block.html
+
+## Object
+
+`obj.key` value: {{obj.key}}.
+
+## Loops
+
+### Literals
+
+<ul>
+  {{#each arrLiterals}}
+    <li>{{this}}</li>
+  {{/each}}
+</ul>
+
+### Objects
+
+<ul>
+  {{#each arrObjects}}
+    <li>{{text}}</li>
+  {{/each}}
+</ul>
+
+https://handlebarsjs.com/examples/builtin-helper-each-block.html