@ronas-it/nx-generators 0.10.2 → 0.10.3

package/.eslintrc.json

@@ -0,0 +1,37 @@
+{
+  "extends": ["../.eslintrc.json"],
+  "ignorePatterns": ["!**/*"],
+  "overrides": [
+    {
+      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.ts", "*.tsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.json"],
+      "parser": "jsonc-eslint-parser",
+      "rules": {
+        "@nx/dependency-checks": [
+          "error",
+          {
+            "ignoredDependencies": ["@nx/expo"]
+          }
+        ]
+      }
+    },
+    {
+      "files": ["./package.json", "./generators.json"],
+      "parser": "jsonc-eslint-parser",
+      "rules": {
+        "@nx/nx-plugin-checks": "error"
+      }
+    }
+  ]
+}

package/jest.config.ts

@@ -0,0 +1,10 @@
+/* eslint-disable */
+export default {
+  displayName: '@ronas-it/nx-generators',
+  preset: '../jest.preset.js',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../coverage/plugin',
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronas-it/nx-generators",
-  "version": "0.10.2",
+  "version": "0.10.3",
   "description": "NX generators for Ronas IT projects",
   "license": "MIT",
   "author": "Ronas IT",
@@ -35,4 +35,4 @@
   "main": "./src/index.js",
   "typings": "./src/index.d.ts",
   "generators": "./generators.json"
-}
+}

package/project.json

@@ -0,0 +1,61 @@
+{
+  "name": "@ronas-it/nx-generators",
+  "$schema": "../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "plugin/src",
+  "projectType": "library",
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/plugin",
+        "main": "plugin/src/index.ts",
+        "tsConfig": "plugin/tsconfig.lib.json",
+        "assets": [
+          "plugin/*.md",
+          {
+            "input": "./plugin/src",
+            "glob": "**/!(*.ts)",
+            "output": "./src"
+          },
+          {
+            "input": "./plugin/src",
+            "glob": "**/*.d.ts",
+            "output": "./src"
+          },
+          {
+            "input": "./plugin",
+            "glob": "generators.json",
+            "output": "."
+          },
+          {
+            "input": "./plugin",
+            "glob": "executors.json",
+            "output": "."
+          }
+        ]
+      }
+    },
+    "nx-release-publish": {
+      "options": {
+        "packageRoot": "dist/{projectRoot}"
+      }
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+      "options": {
+        "jestConfig": "plugin/jest.config.ts"
+      }
+    }
+  },
+  "tags": ["nx", "generator", "monorepo", "expo", "react-native", "typescript"],
+  "release": {
+    "version": {
+      "generatorOptions": {
+        "packageRoot": "dist/{projectRoot}",
+        "currentVersionResolver": "git-tag"
+      }
+    }
+  }
+}

package/src/generators/code-checks/config.ts

@@ -0,0 +1,17 @@
+export default {
+  'lint-staged': {
+    '*.{ts,tsx}': 'tsc-files --noEmit types.d.ts',
+    '*.{ts,tsx,js,html,json,md}': 'prettier --write',
+    '*.{ts,tsx,js}': 'eslint --cache --fix',
+  },
+  tsconfig: {
+    jsx: 'react-native',
+    allowJs: true,
+    noEmit: true,
+    strict: true,
+    allowSyntheticDefaultImports: true,
+    noImplicitAny: true,
+    strictPropertyInitialization: false,
+    strictNullChecks: true,
+  },
+};

package/src/generators/code-checks/generator.ts

@@ -0,0 +1,72 @@
+import { execSync } from 'child_process';
+import * as path from 'path';
+import {
+  addDependenciesToPackageJson,
+  formatFiles,
+  generateFiles,
+  installPackagesTask,
+  readJson,
+  Tree,
+  writeJson,
+} from '@nx/devkit';
+import { devDependencies } from '../../shared/dependencies';
+import config from './config';
+import { CodeChecksGeneratorSchema } from './schema';
+import scripts from './scripts';
+
+export async function codeChecksGenerator(tree: Tree, options: CodeChecksGeneratorSchema) {
+  const projectRoot = '.';
+
+  // Delete files
+  tree.delete('.eslintrc.json');
+  tree.delete('eslint.config.cjs');
+  tree.delete('.prettierrc');
+
+  // Configure pre-commit hook
+  execSync('npx mrm@2 lint-staged', { stdio: 'inherit' });
+
+  const packageJson = readJson(tree, 'package.json');
+  packageJson['lint-staged'] = config['lint-staged'];
+  packageJson.scripts = { ...scripts, ...packageJson.scripts };
+  writeJson(tree, 'package.json', packageJson);
+
+  // Update tsconfig.base.json
+  const tsconfigJson = readJson(tree, 'tsconfig.base.json');
+  tsconfigJson.compilerOptions = { ...config.tsconfig, ...tsconfigJson.compilerOptions };
+  writeJson(tree, 'tsconfig.base.json', tsconfigJson);
+
+  // Update .gitignore
+  const gitignoreContent = tree.read('.gitignore')?.toString() + '\n.eslintcache\n';
+  tree.write('.gitignore', gitignoreContent);
+
+  // Update .eslintignore
+  const eslintignoreContent = tree.read('.eslintignore')?.toString() + '\n**/*.js\napps/*/app.config.ts\n';
+  tree.write('.eslintignore', eslintignoreContent);
+
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const configTemplate = require('../../shared/templates/config-template.json');
+
+  // Add files
+  generateFiles(tree, path.join(__dirname, 'files'), projectRoot, options);
+
+  // Add rules to .eslintrc.json
+  const esLintConfig = readJson(tree, '.eslintrc.json');
+
+  esLintConfig.overrides.push(configTemplate);
+  writeJson(tree, '.eslintrc.json', esLintConfig);
+
+  // Install necessary dependencies
+  addDependenciesToPackageJson(
+    tree,
+    {},
+    devDependencies['code-checks']
+  );
+
+  await formatFiles(tree);
+
+  return () => {
+    installPackagesTask(tree);
+  };
+}
+
+export default codeChecksGenerator;

package/src/generators/code-checks/scripts.ts

@@ -0,0 +1,5 @@
+export default {
+  'lint': 'npx tsc && cross-env ESLINT_USE_FLAT_CONFIG=false npx eslint ./',
+  'format': 'npx prettier --write . && npm run lint -- --fix',
+  'prepare': 'husky',
+}

package/src/generators/entity-api/generator.ts

@@ -0,0 +1,127 @@
+import * as path from 'path';
+import { formatFiles, generateFiles, Tree } from '@nx/devkit';
+import { camelCase, kebabCase, startCase } from 'lodash';
+import { IndentationText, Project, QuoteKind, StructureKind, SyntaxKind } from 'ts-morph';
+import {
+  addNamedImport,
+  appendFileContent,
+  askQuestion,
+  createCliReadline,
+  dynamicImport,
+  filterSource,
+  getNxLibsPaths,
+  LibraryType,
+  searchAliasPath,
+  searchNxLibsPaths
+} from '../../shared/utils';
+import { EntityApiGeneratorSchema } from './schema';
+
+export async function entityApiGenerator(tree: Tree, options: EntityApiGeneratorSchema) {
+  const { default: autocomplete } = await dynamicImport<typeof import('inquirer-autocomplete-standalone')>(
+    'inquirer-autocomplete-standalone',
+  );
+  const nxLibsPaths = getNxLibsPaths([LibraryType.DATA_ACCESS]);
+  const apiLibsPaths = searchNxLibsPaths(nxLibsPaths, 'data-access/api/src', 'endsWith');
+  const apiClientLibsPaths = searchNxLibsPaths(nxLibsPaths, 'data-access/api-client/src', 'endsWith');
+
+  if (!apiClientLibsPaths.length) {
+    throw new Error('Could not find API Client path.');
+  }
+
+  if (!apiLibsPaths.length) {
+    throw new Error('Could not find API path.');
+  }
+
+  if (apiClientLibsPaths.length > 1) {
+    apiClientLibsPaths[0] = await autocomplete({
+      message: 'Select the api client library path:',
+      source: (input) => filterSource(input as string, apiClientLibsPaths)
+    });
+  }
+
+  if (apiLibsPaths.length > 1) {
+    apiLibsPaths[0] = await autocomplete({
+      message: 'Select the api library path:',
+      source: (input) => filterSource(input as string, apiLibsPaths)
+    });
+  }
+
+  const apiDirectory = searchAliasPath(apiLibsPaths[0]) as string;
+  const apiClientDirectory = searchAliasPath(apiClientLibsPaths[0]);
+
+  const libPath = apiLibsPaths[0];
+  const libRootPath = `${libPath}/lib`;
+
+  const cliReadline = createCliReadline();
+  options.name =
+    options.name || (await askQuestion('Enter the name of the entity (e.g: User): ', undefined, cliReadline));
+
+  const apiName = kebabCase(options.name);
+
+  options.baseEndpoint =
+    options.baseEndpoint || (await askQuestion('Enter the base endpoint (e.g: /users): ', `/${apiName}`, cliReadline));
+  cliReadline.close();
+
+  const apiPath = `${libRootPath}/${apiName}`;
+  const entityName = startCase(camelCase(apiName)).replace(/\s+/g, '');
+
+  generateFiles(tree, path.join(__dirname, `files`), apiPath, {
+    ...options,
+    apiName: camelCase(options.name),
+    entityName,
+    entityFileName: apiName,
+    apiClientDirectory,
+    baseEndpoint: options.baseEndpoint.startsWith('/') ? options.baseEndpoint : `/${options.baseEndpoint}`
+  });
+
+  tree.rename(`${apiPath}/models/entity.ts`, `${apiPath}/models/${apiName}.ts`);
+
+  appendFileContent(`${libRootPath}/index.ts`, `export * from './${apiName}';\n`, tree);
+
+  const storeLibsPaths = searchNxLibsPaths(nxLibsPaths, 'data-access/store/src', 'endsWith');
+
+  if (!storeLibsPaths.length) {
+    await formatFiles(tree);
+
+    throw new Error('Could not find redux store path.');
+  }
+
+  if (storeLibsPaths.length > 1) {
+    storeLibsPaths[0] = await autocomplete({
+      message: 'Select the store library path:',
+      source: (input) => filterSource(input as string, storeLibsPaths)
+    });
+  }
+
+  // Update redux store
+  const apiNameDeclaration = camelCase(options.name + 'Api');
+  const project = new Project({
+    manipulationSettings: {
+      indentationText: IndentationText.TwoSpaces,
+      quoteKind: QuoteKind.Single
+    }
+  });
+  const store = project.addSourceFileAtPath(`${storeLibsPaths[0]}/store.ts`);
+
+  addNamedImport(apiNameDeclaration, apiDirectory, store);
+
+  const rootReducer = store.getVariableDeclarationOrThrow('rootReducer');
+
+  rootReducer.getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression).addProperty({
+    name: `[${apiNameDeclaration}.reducerPath]`,
+    initializer: `${apiNameDeclaration}.reducer`,
+    kind: StructureKind.PropertyAssignment
+  });
+
+  const middlewares = store.getVariableDeclarationOrThrow('middlewares');
+
+  middlewares
+    .getInitializerIfKindOrThrow(SyntaxKind.ArrayLiteralExpression)
+    .addElement(`${apiNameDeclaration}.middleware`);
+
+  project.saveSync();
+
+  await formatFiles(tree);
+}
+
+export default entityApiGenerator;

package/src/generators/expo-app/generator.ts

@@ -0,0 +1,152 @@
+import { execSync } from 'child_process';
+import * as path from 'path';
+import {
+  addDependenciesToPackageJson,
+  formatFiles,
+  generateFiles,
+  installPackagesTask,
+  readJson,
+  readProjectConfiguration,
+  Tree,
+  updateProjectConfiguration,
+  writeJson
+} from '@nx/devkit';
+import { ExpoAppGeneratorSchema } from './schema';
+import scripts from './scripts';
+import { existsSync, rmSync } from 'fs';
+import { dependencies, devDependencies } from '../../shared/dependencies';
+import { BaseGeneratorType } from '../../shared/enums';
+import {
+  runAppEnvGenerator,
+  runApiClientGenerator,
+  runStorageGenerator,
+  runRNStylesGenerator,
+  runFormUtilsGenerator,
+  runStoreGenerator,
+  runUIKittenGenerator
+} from '../../shared/generators';
+import { formatName, formatAppIdentifier, addNxAppTag, askQuestion, getImportPathPrefix } from '../../shared/utils';
+
+export async function expoAppGenerator(
+  tree: Tree,
+  options: ExpoAppGeneratorSchema
+) {
+  const shouldGenerateStoreLib = await askQuestion('Do you want to create store lib? (y/n): ') === 'y';
+  const shouldGenerateApiClientLib = shouldGenerateStoreLib && await askQuestion('Do you want to create api client lib? (y/n): ') === 'y';
+  const shouldGenerateAuthLibs = shouldGenerateApiClientLib && await askQuestion('Do you want to create auth lib? (y/n): ') === 'y';
+  const shouldGenerateFormUtilsLib = await askQuestion('Do you want to create a lib with the form utils? (y/n): ') === 'y';
+  const shouldGenerateUIKittenLib = await askQuestion('Do you want to install @ui-kitten? (y/n): ') === 'y';
+
+  const appRoot = `apps/${options.directory}`;
+  const i18nRoot = `i18n/${options.directory}`;
+  const appTestFolder = `apps/${options.directory}-e2e`;
+  const libPath = `${getImportPathPrefix(tree)}/${options.directory}`;
+  const tags = [`app:${options.directory}`, 'type:app'];
+
+  // Install @nx/expo plugin
+  execSync('npx nx add @nx/expo', { stdio: 'inherit' });
+
+  if (existsSync(appRoot)) {
+    const project = readProjectConfiguration(tree, options.directory);
+
+    project.tags = [`app:${options.directory}`, 'type:app'];
+
+    updateProjectConfiguration(tree, project.name as string, project);
+  } else {
+    execSync(
+      `npx nx g @nx/expo:app ${options.name} --directory=apps/${options.directory} --tags="${tags.join(', ')}" --linter=eslint --unitTestRunner=none --e2eTestRunner=none`,
+      { stdio: 'inherit' }
+    );
+  }
+
+  // Generate shared libs
+  await runAppEnvGenerator(tree, { ...options, baseGeneratorType: BaseGeneratorType.EXPO_APP });
+  await runStorageGenerator(tree, options);
+  await runRNStylesGenerator(tree, options);
+
+  if (shouldGenerateStoreLib) {
+    await runStoreGenerator(tree, { ...options, baseGeneratorType: BaseGeneratorType.EXPO_APP });
+  }
+
+  if (shouldGenerateApiClientLib) {
+    await runApiClientGenerator(tree, options);
+  }
+
+  if (shouldGenerateFormUtilsLib) {
+    await runFormUtilsGenerator(tree, options);
+  }
+
+  if (shouldGenerateUIKittenLib) {
+    await runUIKittenGenerator(tree, options);
+  }
+
+  // Workaround: Even with the '--e2eTestRunner=none' parameter, the test folder is created. We delete it manually.
+  if (existsSync(appTestFolder)) {
+    rmSync(appTestFolder, { recursive: true, force: true });
+  }
+
+  const appPackagePath = `${appRoot}/package.json`;
+
+  // Remove unnecessary files and files that will be replaced
+  tree.delete(`${appRoot}/src`);
+  tree.delete(`${appRoot}/index.js`);
+  tree.delete(`${appRoot}/webpack.config.js`);
+  tree.delete(`${appRoot}/.eslintrc.json`);
+  tree.delete(`${appRoot}/eslint.config.cjs`);
+  tree.delete(`${appRoot}/app.json`);
+  tree.delete(`${appRoot}/eas.json`);
+  tree.delete(`${appRoot}/metro.config.js`);
+  tree.delete(`${appRoot}/jest.config.ts`);
+  tree.delete(`${appRoot}/tsconfig.app.json`);
+
+  // Update app package.json
+  const appPackageJson = readJson(tree, appPackagePath);
+  appPackageJson.main = 'expo-router/entry';
+  appPackageJson.scripts = {
+    ...scripts,
+    ...appPackageJson.scripts,
+  };
+  writeJson(tree, appPackagePath, appPackageJson);
+
+  // Add app files
+  generateFiles(tree, path.join(__dirname, 'app-files'), appRoot, {
+    ...options,
+    formatName,
+    formatAppIdentifier,
+    formatDirectory: () => libPath,
+    isUIKittenEnabled: shouldGenerateUIKittenLib,
+    isStoreEnabled: shouldGenerateStoreLib,
+    appDirectory: options.directory
+  });
+
+  addNxAppTag(tree, options.directory);
+  generateFiles(tree, path.join(__dirname, 'i18n'), i18nRoot, {});
+
+  // Add dependencies
+  addDependenciesToPackageJson(
+    tree,
+    {
+      ...dependencies['expo-app'],
+      ...dependencies['expo-app-root']
+    },
+    {
+      ...devDependencies['expo-app'],
+      ...devDependencies['expo-app-root']
+    }
+  );
+
+  addDependenciesToPackageJson(tree, dependencies['expo-app'], devDependencies['expo-app'], appPackagePath);
+
+  await formatFiles(tree);
+
+  return () => {
+    installPackagesTask(tree);
+    execSync('npx expo install --fix', { stdio: 'inherit' });
+
+    if (shouldGenerateAuthLibs) {
+      execSync(`npx nx g auth ${options.name} ${options.directory}`, { stdio: 'inherit' });
+    }
+  };
+}
+
+export default expoAppGenerator;

package/src/generators/expo-app/scripts.ts

@@ -0,0 +1,12 @@
+export default {
+  'start': 'cross-env EXPO_PUBLIC_APP_ENV=development npx expo start',
+  'start:prod': 'cross-env EXPO_PUBLIC_APP_ENV=production npx expo start',
+  'build:dev': 'eas build --no-wait -p all --profile=development',
+  'build:internal': 'npm run build:dev -- --profile=internal',
+  'build:debug': 'npm run build:dev -- --profile=debug',
+  'build:prod': 'npm run build:dev -- --profile=production',
+  'update:dev': 'cross-env EXPO_PUBLIC_APP_ENV=development eas update --branch development',
+  'update:prod': 'cross-env EXPO_PUBLIC_APP_ENV=production eas update --branch production',
+  'submit:dev': 'cross-env EXPO_PUBLIC_APP_ENV=development eas submit --no-wait --profile=development',
+  'submit:prod': 'cross-env EXPO_PUBLIC_APP_ENV=production eas submit --no-wait --profile=production',
+};

package/src/generators/form/generator.ts

@@ -0,0 +1,53 @@
+import { addDependenciesToPackageJson, formatFiles, generateFiles, installPackagesTask, Tree } from '@nx/devkit';
+import * as path from 'path';
+import { FormGeneratorSchema } from './schema';
+import { dynamicImport, formatName, getNxLibsPaths, LibraryType, searchNxLibsPaths } from '../../shared/utils';
+import { dependencies } from '../../shared/dependencies';
+import { addFormUsage, getAppName, getFormUtilsDirectory, updateIndex } from './utils';
+
+export async function formGenerator(tree: Tree, options: FormGeneratorSchema) {
+  // Get input data
+  const { default: autocomplete } = await dynamicImport<typeof import('inquirer-autocomplete-standalone')>('inquirer-autocomplete-standalone');
+  const availableLibsPaths = getNxLibsPaths([LibraryType.FEATURES, LibraryType.UI]);
+  const libPath = await autocomplete({
+    message: 'Enter the library path: ',
+    source: async (input) => {
+      const filteredNxLibsPaths = searchNxLibsPaths(availableLibsPaths, input as string)
+
+      return filteredNxLibsPaths.map((path) => ({ value: path }))
+    }
+  });
+  const fileName = options.name;
+  const placeOfUse = options.placeOfUse;
+
+  if (!fileName) {
+    throw new Error('Form name is required');
+  }
+
+  // Generate form class
+  const formsPath = `${libPath}/lib/forms`;
+  const formFilePath = `${formsPath}/${fileName}.ts`;
+  if (tree.exists(formFilePath)) {
+    throw new Error('The form already exists');
+  }
+
+  const formUtilsDirectory = await getFormUtilsDirectory(tree, getAppName(libPath));
+  const formClassName = `${formatName(fileName, true)}FormSchema`;
+  generateFiles(tree, path.join(__dirname, `files`), formsPath, { className: formClassName, fileName, formUtilsDirectory });
+  updateIndex(formsPath, fileName, tree);
+
+  // Add form usage
+  if (placeOfUse) {
+    await addFormUsage(libPath, placeOfUse, formClassName);
+  }
+
+  await formatFiles(tree);
+
+  // Install dependencies
+  addDependenciesToPackageJson(tree, dependencies.form, {});
+  return () => {
+    installPackagesTask(tree);
+  };
+}
+
+export default formGenerator;

package/src/generators/form/utils/add-form-usage.ts

@@ -0,0 +1,86 @@
+import {
+  ArrowFunction,
+  FunctionDeclaration,
+  FunctionExpression,
+  IndentationText,
+  Project,
+  QuoteKind,
+  SourceFile,
+  SyntaxKind,
+  VariableDeclaration
+} from 'ts-morph';
+import { addNamedImport } from '../../../shared/utils';
+
+function getFormUsageCode(formClassName: string): string {
+  return `const formSchema = new ${formClassName}();
+const form = useForm({
+  defaultValues: formSchema.formValues,
+  resolver: yupResolver(${formClassName}.validationSchema)
+});\n\n`
+}
+
+function getForwardRefFunction(variable: VariableDeclaration): FunctionExpression | ArrowFunction {
+  const callExpressionInitializer = variable.getInitializerIfKind(SyntaxKind.CallExpression);
+  const hasForwardRef = callExpressionInitializer?.getExpression().getText() === 'forwardRef'
+  if (!hasForwardRef) {
+    throw new Error('Could not find forwardRef');
+  }
+
+  const argument = callExpressionInitializer.getArguments()[0];
+  const hasComponentFunction = argument && [SyntaxKind.FunctionExpression, SyntaxKind.ArrowFunction].includes(argument.getKind())
+  if (!hasComponentFunction) {
+    throw new Error('Could not find a component function in forwardRef');
+  }
+
+  const functionExpression = argument.asKind(argument.getKind() === SyntaxKind.FunctionExpression ? SyntaxKind.FunctionExpression : SyntaxKind.ArrowFunction);
+
+  if (!functionExpression) {
+    throw new Error('Could not get a component function in forwardRef');
+  }
+
+  return functionExpression;
+}
+
+function getPlaceOfUse(file: SourceFile, placeOfUseName: string): FunctionExpression | ArrowFunction | FunctionDeclaration {
+  const placeOfUseFunction = file.getFunction(placeOfUseName);
+  if (placeOfUseFunction) {
+    return placeOfUseFunction;
+  }
+
+  const variable = file.getVariableDeclaration(placeOfUseName);
+  if (!variable) {
+    throw new Error(`Could not find the place where the form should be used (${placeOfUseName}).`);
+  }
+
+  return variable.getInitializerIfKind(SyntaxKind.FunctionExpression)
+    || variable.getInitializerIfKind(SyntaxKind.ArrowFunction)
+    || getForwardRefFunction(variable);
+}
+
+export async function addFormUsage(libPath: string, placeOfUseName: string, formClassName: string): Promise<void> {
+  const project = new Project({
+    manipulationSettings: {
+      indentationText: IndentationText.TwoSpaces,
+      quoteKind: QuoteKind.Single
+    }
+  });
+  const files = project.addSourceFilesAtPaths([`${libPath}/lib/**/*.tsx`, `${libPath}/lib/**/*.ts`]);
+  const file = files.find((file) => file.getFunction(placeOfUseName) || file.getVariableDeclaration(placeOfUseName));
+  if (!file) {
+    throw new Error('Could not find the place where the form should be used.');
+  }
+
+  const pathToForm = file.getFilePath().includes('components')
+    ? '../../forms'
+    : file.getFilePath().includes('hooks')
+      ? '../forms'
+      : './forms';
+  addNamedImport(formClassName, pathToForm, file);
+  addNamedImport('useForm', 'react-hook-form', file);
+  addNamedImport('yupResolver', '@hookform/resolvers/yup', file);
+
+  const placeOfUse = getPlaceOfUse(file, placeOfUseName);
+  placeOfUse.setBodyText(`${getFormUsageCode(formClassName)}${placeOfUse.getBodyText()}`);
+
+  project.saveSync();
+}

package/src/generators/form/utils/get-app-name.ts

@@ -0,0 +1,3 @@
+export function getAppName(path: string): string {
+  return path.split('/')[1];
+}