@ronas-it/nx-generators 0.10.3 → 0.10.4

package/src/shared/generators/rn-styles/generator.ts

@@ -1,27 +1,22 @@
 import { execSync } from 'child_process';
 import { existsSync } from 'fs';
 import * as path from 'path';
-import {
-  addDependenciesToPackageJson,
-  formatFiles,
-  generateFiles,
-  Tree,
-} from '@nx/devkit';
+import { addDependenciesToPackageJson, formatFiles, generateFiles, Tree } from '@nx/devkit';
 import { dependencies } from '../../dependencies';
 import { formatName, formatAppIdentifier, getImportPathPrefix } from '../../utils';
 
-export async function runRNStylesGenerator(
-  tree: Tree,
-  options: { name: string; directory: string },
-) {
+export async function runRNStylesGenerator(tree: Tree, options: { name: string; directory: string }): Promise<void> {
   const appRoot = `apps/${options.directory}`;
   const libRoot = `libs/${options.directory}`;
   const libPath = `${getImportPathPrefix(tree)}/${options.directory}`;
 
   // Generate shared libs
-  execSync(`npx nx g react-lib --app=${options.directory} --scope=shared --type=ui --name=styles --withComponent=false`, {
-    stdio: 'inherit',
-  });
+  execSync(
+    `npx nx g react-lib --app=${options.directory} --scope=shared --type=ui --name=styles --withComponent=false`,
+    {
+      stdio: 'inherit',
+    },
+  );
 
   const appPackagePath = `${appRoot}/package.json`;
 

package/src/shared/generators/storage/generator.ts

@@ -1,21 +1,16 @@
 import { execSync } from 'child_process';
 import * as path from 'path';
-import {
-  formatFiles,
-  generateFiles,
-  Tree
-} from '@nx/devkit';
+import { formatFiles, generateFiles, Tree } from '@nx/devkit';
 import { formatName, formatAppIdentifier, getImportPathPrefix } from '../../utils';
 
-export async function runStorageGenerator(
-  tree: Tree,
-  options: { name: string; directory: string }
-) {
+export async function runStorageGenerator(tree: Tree, options: { name: string; directory: string }): Promise<void> {
   const libRoot = `libs/${options.directory}`;
   const libPath = `${getImportPathPrefix(tree)}/${options.directory}`;
 
   // Generate shared libs
-  execSync(`npx nx g react-lib --app=${options.directory} --scope=shared --type=data-access --name=storage`, { stdio: 'inherit' });
+  execSync(`npx nx g react-lib --app=${options.directory} --scope=shared --type=data-access --name=storage`, {
+    stdio: 'inherit',
+  });
 
   // Remove unnecessary files and files that will be replaced
   tree.delete(`${libRoot}/shared/data-access/storage/src/index.ts`);
@@ -25,7 +20,7 @@ export async function runStorageGenerator(
     ...options,
     formatName,
     formatAppIdentifier,
-    formatDirectory: () => libPath
+    formatDirectory: () => libPath,
   });
 
   await formatFiles(tree);

package/src/shared/generators/store/generator.ts

@@ -1,26 +1,20 @@
 import { execSync } from 'child_process';
 import { existsSync } from 'fs';
 import * as path from 'path';
-import {
-  addDependenciesToPackageJson,
-  formatFiles,
-  generateFiles,
-  Tree
-} from '@nx/devkit';
+import { addDependenciesToPackageJson, formatFiles, generateFiles, Tree } from '@nx/devkit';
 import { dependencies } from '../../dependencies';
 import { formatName, formatAppIdentifier, getImportPathPrefix } from '../../utils';
 import { StoreGeneratorSchema } from './schema';
 
-export async function runStoreGenerator(
-  tree: Tree,
-  options: StoreGeneratorSchema
-) {
+export async function runStoreGenerator(tree: Tree, options: StoreGeneratorSchema): Promise<void> {
   const appRoot = `apps/${options.directory}`;
   const libRoot = `libs/${options.directory}`;
   const libPath = `${getImportPathPrefix(tree)}/${options.directory}`;
 
   // Generate shared libs
-  execSync(`npx nx g react-lib --app=${options.directory} --scope=shared --type=data-access --name=store`, { stdio: 'inherit' });
+  execSync(`npx nx g react-lib --app=${options.directory} --scope=shared --type=data-access --name=store`, {
+    stdio: 'inherit',
+  });
 
   const appPackagePath = `${appRoot}/package.json`;
 
@@ -32,7 +26,7 @@ export async function runStoreGenerator(
     ...options,
     formatName,
     formatAppIdentifier,
-    formatDirectory: () => libPath
+    formatDirectory: () => libPath,
   });
 
   // Add dependencies

package/src/shared/generators/ui-kitten/generator.ts

@@ -1,27 +1,22 @@
 import { execSync } from 'child_process';
 import { existsSync } from 'fs';
 import * as path from 'path';
-import {
-  addDependenciesToPackageJson,
-  formatFiles,
-  generateFiles,
-  Tree,
-} from '@nx/devkit';
+import { addDependenciesToPackageJson, formatFiles, generateFiles, Tree } from '@nx/devkit';
 import { dependencies } from '../../dependencies';
 import { formatName, formatAppIdentifier, getImportPathPrefix, LibraryType } from '../../utils';
 
-export async function runUIKittenGenerator(
-  tree: Tree,
-  options: { name: string; directory: string }
-) {
+export async function runUIKittenGenerator(tree: Tree, options: { name: string; directory: string }): Promise<void> {
   const appRoot = `apps/${options.directory}`;
   const libRoot = `libs/${options.directory}`;
   const libPath = `${getImportPathPrefix(tree)}/${options.directory}`;
 
   // Generate shared libs
-  execSync(`npx nx g react-lib --app=${options.directory} --scope=shared --type=${LibraryType.FEATURES} --name=user-theme-provider --withComponent=false`, {
-    stdio: 'inherit',
-  });
+  execSync(
+    `npx nx g react-lib --app=${options.directory} --scope=shared --type=${LibraryType.FEATURES} --name=user-theme-provider --withComponent=false`,
+    {
+      stdio: 'inherit',
+    },
+  );
 
   const appPackagePath = `${appRoot}/package.json`;
 
@@ -38,7 +33,8 @@ export async function runUIKittenGenerator(
 
   // Update styles lib exports
   const stylesLibIndexData = tree.read(`${libRoot}/shared/ui/styles/src/lib/index.ts`);
-  const newStylesLibIndexData = stylesLibIndexData + `export * from './create-adaptive-styles';\nexport * from './eva-theme';\n`;
+  const newStylesLibIndexData =
+    stylesLibIndexData + `export * from './create-adaptive-styles';\nexport * from './eva-theme';\n`;
 
   tree.write(`${libRoot}/shared/ui/styles/src/lib/index.ts`, newStylesLibIndexData);
 

package/src/shared/templates/config-template.json

@@ -17,12 +17,7 @@
           },
           {
             "sourceTag": "type:app",
-            "onlyDependOnLibsWithTags": [
-              "type:features",
-              "type:ui",
-              "type:utils",
-              "type:data-access"
-            ]
+            "onlyDependOnLibsWithTags": ["type:features", "type:ui", "type:utils", "type:data-access"]
           },
           {
             "sourceTag": "type:utils",
@@ -34,12 +29,7 @@
           },
           {
             "sourceTag": "type:features",
-            "onlyDependOnLibsWithTags": [
-              "type:features",
-              "type:data-access",
-              "type:ui",
-              "type:utils"
-            ]
+            "onlyDependOnLibsWithTags": ["type:features", "type:data-access", "type:ui", "type:utils"]
           },
           {
             "sourceTag": "type:ui",

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

@@ -1,15 +1,20 @@
-import * as readline from 'readline';
 import * as fs from 'fs';
+import * as readline from 'readline';
 import { getProjects, ProjectType, Tree } from '@nx/devkit';
-import { dynamicImport } from './dynamic-import';
 import { constants } from './constants';
+import { dynamicImport } from './dynamic-import';
 
-export const createCliReadline = (): readline.Interface => readline.createInterface({
-  input: process.stdin,
-  output: process.stdout,
-})
+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> => {
+export const askQuestion = (
+  question: string,
+  defaultAnswer?: string,
+  cliReadline?: readline.Interface,
+): Promise<string> => {
   const rl = cliReadline || createCliReadline();
 
   if (defaultAnswer) {
@@ -55,9 +60,9 @@ export const validateLibraryType = (type: string): string => {
   }
 
   return type;
-}
+};
 
-export const getNxLibsPaths = (types: Array<LibraryType>) => {
+export const getNxLibsPaths = (types: Array<LibraryType>): Array<string> => {
   const libs = parseLibsPaths();
 
   return Object.values(libs)
@@ -69,18 +74,18 @@ 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) => {
+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>) => {
+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;
@@ -88,19 +93,26 @@ export const filterSource = async (input: string, source: Array<string>) => {
   return filteredData.map((path) => ({ value: path }));
 };
 
-export const appendFileContent = (path: string, endContent: string, tree: Tree) => {
+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.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');
+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) {
@@ -112,7 +124,7 @@ export const selectProject = async (tree: Tree, projectType: ProjectType, messag
     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 } 
+        value: { ...project, name: projectType === 'application' ? project.path.replace('apps/', '') : project.name },
       }));
 
       if (!input) {
@@ -120,11 +132,14 @@ export const selectProject = async (tree: Tree, projectType: ProjectType, messag
       }
 
       return entries.filter((entry) => entry.name.toLowerCase().includes(input.toLowerCase()));
-    }
+    },
   });
 };
 
-export const getLibraryDetailsByName = async (tree: Tree, libraryName?: string): Promise<{ name: string; path: string }> => {
+export const getLibraryDetailsByName = async (
+  tree: Tree,
+  libraryName?: string,
+): Promise<{ name: string; path: string }> => {
   let selectedLibraryName: string;
   let selectedLibraryPath: string;
 

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

@@ -8,10 +8,12 @@ export interface Constraint {
   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']);
+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> } => {
+export const getNxRulesEntryOrThrowError = (
+  config: Record<string, any>,
+): { files: Array<string>; rules: Record<string, any> } => {
   if (!config) {
     throw new Error('ESLint config not found');
   }
@@ -23,17 +25,17 @@ export const getNxRulesEntryOrThrowError = (config: Record<string, any>): { file
   }
 
   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 } => {
+export const readESLintConfig = (tree: Tree): { config: Record<string, any>; path: string } => {
   let path = defaultEsLintConfigPath;
 
   const checkConfigExists = (path: string): void => {
@@ -62,9 +64,7 @@ export const readESLintConfig = (tree: Tree): { config: Record<string, any>, pat
 };
 
 const getNpmScope = (tree: Tree): string | undefined => {
-  const { name } = tree.exists('package.json')
-    ? readJson<{ name?: string }>(tree, 'package.json')
-    : { name: null };
+  const { name } = tree.exists('package.json') ? readJson<{ name?: string }>(tree, 'package.json') : { name: null };
 
   return name?.startsWith('@') ? name.split('/')[0].substring(1) : undefined;
 };
@@ -78,7 +78,10 @@ export const addNxAppTag = (tree: Tree, appDirectory: string): void => {
     return;
   }
 
-  constraints.push({ sourceTag: `app:${appDirectory}`, onlyDependOnLibsWithTags: [`app:${appDirectory}`, 'app:shared'] });
+  constraints.push({
+    sourceTag: `app:${appDirectory}`,
+    onlyDependOnLibsWithTags: [`app:${appDirectory}`, 'app:shared'],
+  });
 
   writeJson(tree, path, config);
 };
@@ -105,7 +108,15 @@ export const getImportPathPrefix = (tree: Tree): string => {
 
 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'];
+  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}`);
@@ -114,7 +125,9 @@ export const verifyEsLintConfig = (tree: Tree): Record<string, any> => {
   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 areRulesDisabled = rulesEntry[1].depConstraints.find(
+      (rule: Constraint) => rule.sourceTag === '*' && rule.onlyDependOnLibsWithTags.includes('*'),
+    );
     const areRulesBroken = !importantTags.every((tag) => tags.includes(tag));
 
     if (rulesEntry[0] !== 'error') {
@@ -125,7 +138,7 @@ export const verifyEsLintConfig = (tree: Tree): Record<string, any> => {
       // 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];
 

package/src/shared/utils/constants.ts

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

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

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

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

@@ -1,16 +1,15 @@
-export const formatName = (value: string, withoutSpaces = false) =>
+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) =>
-  value.toLowerCase().replace(/-/g, '.');
+export const formatAppIdentifier = (value: string): string => value.toLowerCase().replace(/-/g, '.');
 
-export const getProjectName = (str: string) => {
+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) => path.split('/').pop();
+export const getLibName = (path: string): string | undefined => path.split('/').pop();

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

@@ -4,6 +4,7 @@ export function getLibDirectoryName(libName: string, scopeName: string): string
   let newLibWords = libWords;
 
   const startsWithScopeWords = scopeWords.every((word, index) => libWords[index] === word);
+
   if (startsWithScopeWords && libWords.length > scopeWords.length) {
     newLibWords = libWords.slice(scopeWords.length);
   }

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

@@ -2,16 +2,19 @@ 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()
+    const hasNamedImport = importDeclaration
+      .getNamedImports()
       .find((declaration) => declaration.getName() === namedImport);
+
     if (!hasNamedImport) {
       importDeclaration.addNamedImport(namedImport);
     }
   } else {
     file.addImportDeclaration({
       namedImports: [namedImport],
-      moduleSpecifier
-    })
+      moduleSpecifier,
+    });
   }
-}
+};

package/tsconfig.spec.json

@@ -5,10 +5,5 @@
     "module": "commonjs",
     "types": ["jest", "node"]
   },
-  "include": [
-    "jest.config.ts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.d.ts"
-  ]
+  "include": ["jest.config.ts", "src/**/*.test.ts", "src/**/*.spec.ts", "src/**/*.d.ts"]
 }