@ronas-it/nx-generators 0.10.4 → 0.10.5

package/src/shared/utils/cli-utils.ts

@@ -1,164 +0,0 @@
-import * as fs from 'fs';
-import * as readline from 'readline';
-import { getProjects, ProjectType, Tree } from '@nx/devkit';
-import { constants } from './constants';
-import { dynamicImport } from './dynamic-import';
-
-export const createCliReadline = (): readline.Interface =>
-  readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-
-export const askQuestion = (
-  question: string,
-  defaultAnswer?: string,
-  cliReadline?: readline.Interface,
-): Promise<string> => {
-  const rl = cliReadline || createCliReadline();
-
-  if (defaultAnswer) {
-    rl.write(defaultAnswer);
-    // Move cursor to end of the line
-    setTimeout(() => rl.write(null, { ctrl: true, name: 'e' }));
-  }
-
-  return new Promise((resolve) =>
-    rl.question(question, (answer) => {
-      if (!cliReadline) {
-        rl.close();
-      }
-      resolve(answer);
-    }),
-  );
-};
-
-export enum LibraryType {
-  UI = 'ui',
-  DATA_ACCESS = 'data-access',
-  FEATURES = 'features',
-  UTILS = 'utils',
-}
-
-const parseLibsPaths = (): Record<string, Array<string>> => {
-  let tsconfig;
-
-  if (fs.existsSync('tsconfig.base.json')) {
-    tsconfig = JSON.parse(fs.readFileSync('tsconfig.base.json', 'utf8'));
-  } else {
-    tsconfig = JSON.parse(fs.readFileSync('tsconfig.json', 'utf8'));
-  }
-
-  return tsconfig.compilerOptions.paths;
-};
-
-export const validateLibraryType = (type: string): string => {
-  const allLibraryTypes = Object.values(LibraryType);
-
-  if (!allLibraryTypes.includes(type as LibraryType)) {
-    throw new Error(`Invalid library type: ${type}.\nAvailable types: ${allLibraryTypes.join(', ')}`);
-  }
-
-  return type;
-};
-
-export const getNxLibsPaths = (types: Array<LibraryType>): Array<string> => {
-  const libs = parseLibsPaths();
-
-  return Object.values(libs)
-    .map((value) => value[0].replace('/index.ts', ''))
-    .filter((value) => types.some((type) => value.includes(type)));
-};
-
-export const searchNxLibsPaths = (
-  paths: Array<string>,
-  input: string,
-  method: 'includes' | 'startsWith' | 'endsWith' = 'includes',
-): Array<string> => {
-  return paths.filter((path) => path[method](input));
-};
-
-export const searchAliasPath = (input: string): string | undefined => {
-  const libs = parseLibsPaths();
-  const path = Object.keys(libs).find((key) => libs[key][0].includes(input));
-
-  return path;
-};
-
-export const filterSource = async (input: string, source: Array<string>): Promise<Array<{ value: string }>> => {
-  const filteredData = input
-    ? source.filter((pathname) => pathname.toLowerCase().includes(input.toLowerCase()))
-    : source;
-
-  return filteredData.map((path) => ({ value: path }));
-};
-
-export const appendFileContent = (path: string, endContent: string, tree: Tree): void => {
-  const content = tree.read(path, 'utf-8');
-  const contentUpdate = (content || '') + endContent;
-
-  tree.write(path, contentUpdate);
-};
-
-export const getProjectsDetails = (tree: Tree, projectType: ProjectType): Array<{ name: string; path: string }> =>
-  Array.from(getProjects(tree))
-    .filter(([_, project]) => project.projectType === projectType)
-    .map(([name, project]) => ({ name, path: project.root }));
-
-export const selectProject = async (
-  tree: Tree,
-  projectType: ProjectType,
-  message: string,
-): Promise<{ name: string; path: string }> => {
-  const { default: autocomplete } = await dynamicImport<typeof import('inquirer-autocomplete-standalone')>(
-    'inquirer-autocomplete-standalone',
-  );
-  const projects = getProjectsDetails(tree, projectType);
-
-  if (!projects.length) {
-    throw new Error(`No projects of type ${projectType} found.`);
-  }
-
-  return autocomplete({
-    message,
-    source: async (input) => {
-      const entries = [...projects, { name: constants.sharedValue, path: constants.sharedValue }].map((project) => ({
-        name: `${project.name} (${project.path})`,
-        value: { ...project, name: projectType === 'application' ? project.path.replace('apps/', '') : project.name },
-      }));
-
-      if (!input) {
-        return entries;
-      }
-
-      return entries.filter((entry) => entry.name.toLowerCase().includes(input.toLowerCase()));
-    },
-  });
-};
-
-export const getLibraryDetailsByName = async (
-  tree: Tree,
-  libraryName?: string,
-): Promise<{ name: string; path: string }> => {
-  let selectedLibraryName: string;
-  let selectedLibraryPath: string;
-
-  if (libraryName) {
-    selectedLibraryName = libraryName;
-
-    const library = getProjectsDetails(tree, 'library').find((library) => library.name === selectedLibraryName);
-
-    if (!library) {
-      throw new Error(`Library ${selectedLibraryName} not found`);
-    }
-
-    selectedLibraryPath = library.path;
-  } else {
-    const selectedLibrary = await selectProject(tree, 'library', 'Select the library to move: ');
-
-    selectedLibraryName = selectedLibrary.name;
-    selectedLibraryPath = selectedLibrary.path;
-  }
-
-  return { name: selectedLibraryName, path: selectedLibraryPath };
-};

package/src/shared/utils/config-utils.ts

@@ -1,159 +0,0 @@
-import { Tree, output, readJson, writeJson } from '@nx/devkit';
-import { isEmpty } from 'lodash';
-
-const defaultEsLintConfigPath = '.eslintrc.json';
-
-export interface Constraint {
-  sourceTag: string;
-  onlyDependOnLibsWithTags: Array<string>;
-}
-
-const getNxRulesEntry = (config: Record<string, any>): { files: Array<string>; rules: Record<string, any> } =>
-  config.overrides?.find((entry: { rules: { [x: string]: any } }) => !!entry.rules['@nx/enforce-module-boundaries']);
-
-export const getNxRulesEntryOrThrowError = (
-  config: Record<string, any>,
-): { files: Array<string>; rules: Record<string, any> } => {
-  if (!config) {
-    throw new Error('ESLint config not found');
-  }
-
-  const entryWithRules = getNxRulesEntry(config);
-
-  if (!entryWithRules) {
-    throw new Error(`ESLint: can't find '@nx/enforce-module-boundaries' rule`);
-  }
-
-  return entryWithRules;
-};
-
-export const getNxRulesStatus = (config: Record<string, any>): string => {
-  return getNxRulesEntryOrThrowError(config).rules['@nx/enforce-module-boundaries'][0];
-};
-
-export const getNxRules = (config: Record<string, any>): Array<Constraint> => {
-  return getNxRulesEntryOrThrowError(config).rules['@nx/enforce-module-boundaries'][1].depConstraints;
-};
-
-export const readESLintConfig = (tree: Tree): { config: Record<string, any>; path: string } => {
-  let path = defaultEsLintConfigPath;
-
-  const checkConfigExists = (path: string): void => {
-    if (!tree.exists(path)) {
-      throw new Error(`ESLint config not found: ${path}`);
-    }
-  };
-
-  checkConfigExists(path);
-
-  let config = readJson(tree, path);
-
-  if (getNxRulesEntry(config)) {
-    return { config, path };
-  }
-
-  if (config.extends?.length) {
-    path = config.extends[0];
-
-    checkConfigExists(path);
-
-    config = readJson(tree, config.extends[0]);
-  }
-
-  return { config, path };
-};
-
-const getNpmScope = (tree: Tree): string | undefined => {
-  const { name } = tree.exists('package.json') ? readJson<{ name?: string }>(tree, 'package.json') : { name: null };
-
-  return name?.startsWith('@') ? name.split('/')[0].substring(1) : undefined;
-};
-
-export const addNxAppTag = (tree: Tree, appDirectory: string): void => {
-  const { config, path } = readESLintConfig(tree);
-  const constraints = getNxRules(config);
-  const doesTagExist = !!constraints.find((constraint) => constraint.sourceTag === `app:${appDirectory}`);
-
-  if (doesTagExist) {
-    return;
-  }
-
-  constraints.push({
-    sourceTag: `app:${appDirectory}`,
-    onlyDependOnLibsWithTags: [`app:${appDirectory}`, 'app:shared'],
-  });
-
-  writeJson(tree, path, config);
-};
-
-export const addNxScopeTag = (tree: Tree, scope: string): void => {
-  const { config, path } = readESLintConfig(tree);
-  const constraints = getNxRules(config);
-  const doesTagExist = !!constraints.find((constraint) => constraint.sourceTag === `scope:${scope}`);
-
-  if (doesTagExist) {
-    return;
-  }
-
-  constraints.push({ sourceTag: `scope:${scope}`, onlyDependOnLibsWithTags: [`scope:${scope}`, 'scope:shared'] });
-
-  writeJson(tree, path, config);
-};
-
-export const getImportPathPrefix = (tree: Tree): string => {
-  const npmScope = getNpmScope(tree);
-
-  return npmScope ? `${npmScope === '@' ? '' : '@'}${npmScope}` : '';
-};
-
-export const verifyEsLintConfig = (tree: Tree): Record<string, any> => {
-  const { config, path } = readESLintConfig(tree);
-  const importantTags = [
-    'app:shared',
-    'scope:shared',
-    'type:app',
-    'type:data-access',
-    'type:features',
-    'type:ui',
-    'type:utils',
-  ];
-
-  if (!config || isEmpty(config)) {
-    throw new Error(`Failed to load ESLint config: ${path}`);
-  }
-
-  try {
-    const rulesEntry = getNxRulesEntryOrThrowError(config).rules['@nx/enforce-module-boundaries'];
-    const tags = rulesEntry[1].depConstraints.map((rule: Constraint) => rule.sourceTag);
-    const areRulesDisabled = rulesEntry[1].depConstraints.find(
-      (rule: Constraint) => rule.sourceTag === '*' && rule.onlyDependOnLibsWithTags.includes('*'),
-    );
-    const areRulesBroken = !importantTags.every((tag) => tags.includes(tag));
-
-    if (rulesEntry[0] !== 'error') {
-      rulesEntry[0] = 'error';
-    }
-
-    if (areRulesDisabled || areRulesBroken) {
-      // eslint-disable-next-line @typescript-eslint/no-var-requires
-      const esLintConfigTemplate = require('../templates/config-template.json');
-      const templateRules = esLintConfigTemplate.rules['@nx/enforce-module-boundaries'];
-
-      rulesEntry[0] = templateRules[0];
-      rulesEntry[1] = templateRules[1];
-
-      writeJson(tree, path, config);
-    }
-    // TODO: use custom errors
-  } catch {
-    output.warn({ title: output.bold('ESLint config has no @nx/enforce-module-boundaries rule. Updating rules...') });
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const esLintConfigRulesTemplate = require('../templates/config-template.json');
-
-    config.overrides.push(esLintConfigRulesTemplate);
-
-    writeJson(tree, path, config);
-  }
-
-  return config;
-};

package/src/shared/utils/constants.ts

@@ -1,3 +0,0 @@
-export const constants = {
-  sharedValue: 'shared',
-};

package/src/shared/utils/dynamic-import.ts

@@ -1,3 +0,0 @@
-export const dynamicImport = new Function('specifier', 'return import(specifier)') as <T = never>(
-  specifier: string,
-) => Promise<T>;

package/src/shared/utils/format-utils.ts

@@ -1,15 +0,0 @@
-export const formatName = (value: string, withoutSpaces = false): string =>
-  value
-    .split('-')
-    .map((word) => `${word.charAt(0).toUpperCase()}${word.substring(1)}`)
-    .join(withoutSpaces ? '' : ' ');
-
-export const formatAppIdentifier = (value: string): string => value.toLowerCase().replace(/-/g, '.');
-
-export const getProjectName = (str: string): string => {
-  const parts = str.split('@');
-
-  return parts.length > 1 ? parts[1].split('/')[0] : parts[0];
-};
-
-export const getLibName = (path: string): string | undefined => path.split('/').pop();

package/src/shared/utils/get-lib-directory-name.ts

@@ -1,13 +0,0 @@
-export function getLibDirectoryName(libName: string, scopeName: string): string {
-  const libWords = libName.split('-');
-  const scopeWords = scopeName.split('-');
-  let newLibWords = libWords;
-
-  const startsWithScopeWords = scopeWords.every((word, index) => libWords[index] === word);
-
-  if (startsWithScopeWords && libWords.length > scopeWords.length) {
-    newLibWords = libWords.slice(scopeWords.length);
-  }
-
-  return newLibWords.join('-');
-}

package/src/shared/utils/ts-utils.ts

@@ -1,20 +0,0 @@
-import { SourceFile } from 'ts-morph';
-
-export const addNamedImport = (namedImport: string, moduleSpecifier: string, file: SourceFile): void => {
-  const importDeclaration = file.getImportDeclaration(moduleSpecifier);
-
-  if (importDeclaration) {
-    const hasNamedImport = importDeclaration
-      .getNamedImports()
-      .find((declaration) => declaration.getName() === namedImport);
-
-    if (!hasNamedImport) {
-      importDeclaration.addNamedImport(namedImport);
-    }
-  } else {
-    file.addImportDeclaration({
-      namedImports: [namedImport],
-      moduleSpecifier,
-    });
-  }
-};

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "compilerOptions": {
-    "module": "commonjs"
-  },
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}

package/tsconfig.lib.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../dist/out-tsc",
-    "declaration": true,
-    "types": ["node"]
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
-}

package/tsconfig.spec.json

@@ -1,9 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../dist/out-tsc",
-    "module": "commonjs",
-    "types": ["jest", "node"]
-  },
-  "include": ["jest.config.ts", "src/**/*.test.ts", "src/**/*.spec.ts", "src/**/*.d.ts"]
-}