// 从 `@angular-devkit/schematics` 导入 `Rule`, `SchematicContext`, 和 `Tree`
import { Rule, SchematicContext, Tree } from '@angular-devkit/schematics';
// 导出一个名为 `generateFiles` 的函数，该函数接收 `_options` 参数并返回一个 `Rule` 类型
export function generateFiles(_options: any): Rule {
  // 返回一个函数，该函数接收 `tree` 和 `_context` 参数，并返回 `tree`
  return (tree: Tree, _context: SchematicContext) => {
    console.log('generateFiles', _options);
    // 直接返回传入的 `tree`，没有对 `tree` 进行任何修改
    return tree;
  };
}

export class <%= classify(entityName) %>Controller {}

// 导入需要的依赖模块和函数
import { Rule, SchematicContext, Tree, applyTemplates, url, move, apply, chain, mergeWith } from '@angular-devkit/schematics';
// 导入字符串处理工具
import { strings } from '@angular-devkit/core';
// 导入Node.js内置模块，用于处理文件路径
import * as path from 'path';
// 定义并导出名为 `generateFiles` 的函数，接收参数 `options`，返回一个 `Rule` 类型
export function generateFiles(options: any): Rule {
    // 返回一个匿名函数，接收 `Tree` 和 `SchematicContext` 参数
    return (_tree: Tree, _context: SchematicContext) => {
        // 从选项中获取 `name` 属性并赋值给 `entityName`
        const entityName = options.name;
        // 定义要应用的模板规则
        const sourceTemplateRules = apply(
            // 指定模板文件所在的目录
            url('./files'),
            [
                // 应用模板，将传入的选项和字符串工具一起传递到模板中
                applyTemplates({
                    ...options,
                    ...strings,
                    entityName
                }),
                // 移动生成的文件到目标目录
                move(path.normalize(`target`)),
            ]
        );
        // 返回一个 `chain`，将模板规则与文件系统合并
        return chain([
            mergeWith(sourceTemplateRules),
        ]);
    };
}

+import { Rule, SchematicContext, Tree, applyTemplates, url, move, apply, mergeWith, chain } from '@angular-devkit/schematics';
// Rule: 描述一个规则，可以对文件系统进行更改。
// SchematicContext: 提供有关操作上下文的信息。
// Tree: 表示文件系统的抽象结构。
// applyTemplates: 将模板应用到文件内容中。
// url: 用于加载文件的源路径。
// move: 移动文件到指定路径。
// apply: 应用一组规则到源路径。
// mergeWith: 将模板生成的树合并到现有树中。
// chain: 串联多个规则操作。
import { strings } from '@angular-devkit/core';
// 导入字符串操作工具集，如 dasherize、camelize 等。
import * as path from 'path';
// 导入 Node.js 的路径模块，用于处理和规范化文件路径。
+import { plural } from 'pluralize';
// 导入 pluralize 库中的 plural 函数，该函数用于将单词转换为复数形式。
export function generateFiles(options: any): Rule {
  // 导出一个名为 generateFiles 的函数，它接受选项并返回一个 Rule。
  return (_tree: Tree, _context: SchematicContext) => {
    // 返回一个接收 Tree 和 SchematicContext 的函数，这是 Rule 的基本结构。
    const entityName = options.name;
    // 获取传入的选项中的 name 属性，并将其赋值给 entityName。
+   const sourceTemplateRules = apply(url('./files/src'), [
+     applyTemplates({
+       ...options,
+       ...strings,
+       plural,
+       entityName
+     }),
+     move(path.normalize(`src`)),
+   ]);
    // 定义了一个 sourceTemplateRules 变量，使用 apply 函数从指定的 URL 路径加载文件，
    // 然后应用一系列模板规则，包括字符串处理（如 dasherize、camelize）、plural 函数以及传入的选项。
    // 最后，使用 move 函数将生成的文件移动到 'src' 目录。
    return chain([
+     mergeWith(sourceTemplateRules)
    ]);
    // 使用 chain 函数组合多个规则（这里只有一个），并返回一个包含合并操作的规则。
  };
}

import { ApiProperty } from '@nestjs/swagger';
import { Entity, Column, PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn } from 'typeorm';

@Entity()
export class <%= classify(entityName) %> {
    @PrimaryGeneratedColumn()
    @ApiProperty({ description: 'ID', example: 1 })
    id: number;

    @Column({ length: 50, unique: true })
    @ApiProperty({ description: '名称', example: 'name' })
    name: string;

    @Column({ default: 1 })
    @ApiProperty({ description: '生效状态', example: 1 })
    status: number;

    @Column({ default: 100 })
    @ApiProperty({ description: '排序号', example: 100 })
    sort: number;

    @CreateDateColumn()
    @ApiProperty({ description: '创建时间', example: '2024年8月11日16:49:22' })
    createdAt: Date;

    @UpdateDateColumn()
    @ApiProperty({ description: '更新时间', example: '2024年8月11日16:49:22' })
    updatedAt: Date;
}

import { ApiProperty, PartialType as PartialTypeFromSwagger } from '@nestjs/swagger';
import { IsString, IsOptional } from 'class-validator';
import { PartialType } from '@nestjs/mapped-types';
import { IdValidators, StatusValidators, SortValidators } from '../decorators/dto.decorator';

export class Create<%= classify(entityName) %>Dto {
    @IsString()
    @ApiProperty({ description: '名称', example: 'name' })
    name: string;

    @StatusValidators()
    @ApiProperty({ description: '状态', example: 1 })
    status: number;

    @SortValidators()
    @ApiProperty({ description: '排序号', example: 100 })
    sort: number;
}

export class Update<%= classify(entityName) %>Dto extends PartialTypeFromSwagger(PartialType(Create<%= classify(entityName) %>Dto)) {
    @IdValidators()
    id: number;

    @IsString()
    @IsOptional()
    @ApiProperty({ description: '用户名', example: 'nick' })
    username: string;

    @ApiProperty({ description: '密码', example: '666666' })
    @IsOptional()
    password: string;
}

import { Injectable } from "@nestjs/common";
import { InjectRepository } from "@nestjs/typeorm";
import { <%= classify(entityName) %> } from "../entities/<%= dasherize(entityName) %>.entity";
import { Repository, Like } from 'typeorm';
import { MySQLBaseService } from "./mysql-base.service";

@Injectable()
export class <%= classify(entityName) %>Service extends MySQLBaseService<<%= classify(entityName) %>> {
  constructor(
    @InjectRepository(<%= classify(entityName) %>) protected repository: Repository<<%= classify(entityName) %>>
  ) {
    super(repository);
  }

  async findAll(keyword?: string) {
    const where = keyword ? [
      { name: Like(`%${keyword}%`) }
    ] : {};
    return this.repository.find({ where });
  }

  async findAllWithPagination(page: number, limit: number, keyword?: string) {
    const where = keyword ? [
      { name: Like(`%${keyword}%`) }
    ] : {};
    const [<%= camelize(plural(entityName)) %>, total] = await this.repository.findAndCount({
      where,
      skip: (page - 1) * limit,
      take: limit
    });
    return { <%= camelize(plural(entityName)) %>, total };
  }
}

import { Controller, Get, Render, Post, Redirect, Body, UseFilters, HttpException, Param, ParseIntPipe, Put, Delete, Headers, Res, Query } from '@nestjs/common';
import { Create<%= classify(entityName) %>Dto, Update<%= classify(entityName) %>Dto } from 'src/shared/dto/<%= dasherize(entityName) %>.dto';
import { <%= classify(entityName) %>Service } from 'src/shared/services/<%= dasherize(entityName) %>.service';
import { AdminExceptionFilter } from '../filters/admin-exception-filter';
import { UtilityService } from 'src/shared/services/utility.service';
import { Response } from 'express';
import { ParseOptionalIntPipe } from 'src/shared/pipes/parse-optional-int.pipe';

@UseFilters(AdminExceptionFilter)
@Controller('admin/<%= dasherize(plural(entityName)) %>')
export class <%= classify(entityName) %>Controller {
    constructor(
        private readonly <%= camelize(entityName) %>Service: <%= classify(entityName) %>Service
    ) { }

    @Get()
    @Render('<%= dasherize(entityName) %>/<%= dasherize(entityName) %>-list')
    async findAll(@Query('keyword') keyword: string = '',
        @Query('page', new ParseOptionalIntPipe(1)) page: number,
        @Query('limit', new ParseOptionalIntPipe(10)) limit: number) {
        const { <%= camelize(plural(entityName)) %>, total } = await this.<%= camelize(entityName) %>Service.findAllWithPagination(page, limit, keyword);
        const pageCount = Math.ceil(total / limit);
        return { <%= camelize(plural(entityName)) %>, keyword, page, limit, pageCount };
    }

    @Get('create')
    @Render('<%= dasherize(entityName) %>/<%= dasherize(entityName) %>-form')
    createForm() {
        return { <%= camelize(entityName) %>: {} }
    }

    @Post()
    @Redirect('/admin/<%= dasherize(plural(entityName)) %>')
    async create(@Body() create<%= classify(entityName) %>Dto: Create<%= classify(entityName) %>Dto) {
        await this.<%= camelize(entityName) %>Service.create(create<%= classify(entityName) %>Dto);
        return { success: true }
    }

    @Get(':id/edit')
    @Render('<%= dasherize(entityName) %>/<%= dasherize(entityName) %>-form')
    async editForm(@Param('id', ParseIntPipe) id: number) {
        const <%= camelize(entityName) %> = await this.<%= camelize(entityName) %>Service.findOne({ where: { id } });
        if (!<%= camelize(entityName) %>) throw new HttpException('<%= classify(entityName) %> not Found', 404);
        return { <%= camelize(entityName) %> };
    }

    @Put(':id')
    async update(@Param('id', ParseIntPipe) id: number, @Body() update<%= classify(entityName) %>Dto: Update<%= classify(entityName) %>Dto, @Res({ passthrough: true }) res: Response, @Headers('accept') accept: string) {
        await this.<%= camelize(entityName) %>Service.update(id, update<%= classify(entityName) %>Dto);
        if (accept === 'application/json') {
            return { success: true };
        } else {
            return res.redirect(`/admin/<%= dasherize(plural(entityName)) %>`);
        }
    }

    @Delete(":id")
    async delete(@Param('id', ParseIntPipe) id: number) {
        await this.<%= camelize(entityName) %>Service.delete(id);
        return { success: true }
    }

    @Get(':id')
    @Render('<%= dasherize(entityName) %>/<%= dasherize(entityName) %>-detail')
    async findOne(@Param('id', ParseIntPipe) id: number) {
        const <%= camelize(entityName) %> = await this.<%= camelize(entityName) %>Service.findOne({ where: { id } });
        if (!<%= camelize(entityName) %>) throw new HttpException('<%= classify(entityName) %> not Found', 404);
        return { <%= camelize(entityName) %> };
    }
}

import { Rule, SchematicContext, Tree, applyTemplates, url, move, apply, mergeWith, chain } from '@angular-devkit/schematics';
import { strings } from '@angular-devkit/core';
import * as path from 'path';
import { plural } from 'pluralize';
export function generateFiles(options: any): Rule {
  return (_tree: Tree, _context: SchematicContext) => {
    const entityName = options.name;
+   const title = options.path;
    const sourceTemplateRules = apply(url('./files/src'), [
      applyTemplates({
        ...options,
        ...strings,
        plural,
        entityName
      }),
      move(path.normalize(`src`)),
    ]);
+   const viewsTemplateRules = apply(url('./files/views'), [
+     applyTemplates({
+       ...options,
+       ...strings,
+       plural,
+       entityName,
+       title
+     }),
+     move(path.normalize(`views`)),
+   ]);
    return chain([
+     mergeWith(sourceTemplateRules),
+     mergeWith(viewsTemplateRules),
    ]);
  };
}

// 从 @angular-devkit/schematics 导入所需的工具和函数
import { Rule, SchematicContext, Tree, applyTemplates, url, move, apply, mergeWith, chain } from '@angular-devkit/schematics';
// 从 @angular-devkit/core 导入字符串处理工具
import { strings } from '@angular-devkit/core';
// 导入 path 模块用于处理文件路径
import * as path from 'path';
// 导入 pluralize 库用于处理复数形式
import { plural } from 'pluralize';
// 导入 TypeScript 模块用于处理 TypeScript 文件的解析和变更
+import * as ts from 'typescript';
// 导出名为 generateFiles 的函数，返回一个 Rule 规则
export function generateFiles(options: any): Rule {
    // 返回一个函数，该函数接收 Tree 和 SchematicContext 作为参数
    return (_tree: Tree, _context: SchematicContext) => {
        // 从传入的选项中获取实体名称
        const entityName = options.name;
        // 从传入的选项中获取路径标题
        const title = options.path;
        // 定义处理源模板的规则
        const sourceTemplateRules = apply(url('./files/src'), [
            // 应用模板，将传入的选项与字符串和复数处理工具合并
            applyTemplates({
                ...options,
                ...strings,
                plural,
                entityName
            }),
            // 将生成的文件移动到目标路径
            move(path.normalize(`src`)),
        ]);
        // 定义处理视图模板的规则
        const viewsTemplateRules = apply(url('./files/views'), [
            // 应用模板，将传入的选项与字符串和复数处理工具合并
            applyTemplates({
                ...options,
                ...strings,
                plural,
                entityName,
                title
            }),
            // 将生成的视图文件移动到目标路径
            move(path.normalize(`views`)),
        ]);
        // 返回一个链式规则，应用源模板和视图模板的规则
        return chain([
            mergeWith(sourceTemplateRules),
            mergeWith(viewsTemplateRules),
            // 调用 updateAdminModule 函数更新 AdminModule
+           updateAdminModule(entityName),
        ]);
    };
}
+// 定义函数 updateAdminModule 用于更新 AdminModule 文件
+function updateAdminModule(entityName: string) {
+    // 返回一个函数，接收 Tree 作为参数
+    return (tree: Tree) => {
+        // 定义 AdminModule 文件的路径
+        const adminModulePath = 'src/admin/admin.module.ts';
+        // 读取并解析 AdminModule 文件为 TypeScript 源文件
+        const sourceFile = getSourceFile(tree, adminModulePath);
+        // 如果源文件存在
+        if (sourceFile) {
+            // 获取实体名称的分类形式和破折号形式
+            const { classifiedName, dasherizedName } = getClassifiedAndDasherizedName(entityName);
+            // 定义更新操作，添加控制器导入和控制器数组的更新
+            const updates = [
+                addImportToModule(`${classifiedName}Controller`, `./controllers/${dasherizedName}.controller`),
+                addToModuleArray(`controllers`, `${classifiedName}Controller`)
+            ];
+            // 应用更新并保存变更到 AdminModule 文件
+            applyTransformationsAndSave(tree, adminModulePath, sourceFile, updates);
+        }
+        // 返回修改后的 Tree
+        return tree;
+    };
+}
+// 定义函数 getClassifiedAndDasherizedName 获取分类名称和破折号形式名称
+function getClassifiedAndDasherizedName(name: string) {
+    // 将名称转换为分类形式（驼峰形式）
+    const classifiedName = strings.classify(name);
+    // 将分类形式名称转换为破折号形式
+    const dasherizedName = strings.dasherize(classifiedName);
+    // 返回分类形式名称和破折号形式名称的对象
+    return { classifiedName, dasherizedName };
+}
+// 定义函数 getSourceFile 用于读取并解析源文件为 TypeScript 源文件对象
+function getSourceFile(tree: Tree, filePath: string): ts.SourceFile | undefined {
+    // 读取指定路径的文件内容，并转换为字符串
+    const content = tree.read(filePath)?.toString('utf-8');
+    // 使用 TypeScript 创建源文件对象
+    return ts.createSourceFile(filePath, content!, ts.ScriptTarget.Latest, true);
+}
+// 定义函数 addImportToModule 用于在模块文件中添加导入语句
+function addImportToModule(importName: string, importPath: string): ts.TransformerFactory<ts.SourceFile> {
+    // 返回一个转换工厂函数，用于在指定文件中插入导入语句
+    //TransformerFactory 是一个高阶函数，它接收 TransformationContext 并返回另一个处理 SourceFile 的函数。这个返回的函数用来操作传入的源文件 rootNode。
+    return (_context: ts.TransformationContext) => (rootNode: ts.SourceFile) => {
+        // 查找文件中的最后一个导入声明
+        const lastImport = rootNode.statements.filter(ts.isImportDeclaration).pop();
+        // 创建一个新的导入声明
+        const newImport = ts.factory.createImportDeclaration(
+            undefined,
+            ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
+                ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(importName)),
+            ])),
+            ts.factory.createStringLiteral(importPath)
+        );
+        // 在最后一个导入声明后插入新的导入声明
+        const updatedStatements = ts.factory.createNodeArray([
+            ...rootNode.statements.slice(0, rootNode.statements.indexOf(lastImport!) + 1),
+            newImport,
+            ...rootNode.statements.slice(rootNode.statements.indexOf(lastImport!) + 1),
+        ]);
+        //创建一个新的源文件对象，它包含了插入新导入声明后的所有语句。返回这个更新后的 SourceFile
+        return ts.factory.updateSourceFile(rootNode, updatedStatements) as ts.SourceFile;
+    };
+}
+// 定义函数 addToModuleArray 用于在模块的控制器数组中添加新控制器
+function addToModuleArray(arrayName: string, itemName: string): ts.TransformerFactory<ts.SourceFile> {
+    // 返回一个转换工厂函数，用于更新数组属性
+    return (context: ts.TransformationContext) => (rootNode: ts.SourceFile) => {
+        // 定义访问器函数，递归遍历节点
+        function visitor(node: ts.Node): ts.Node {
+            // 检查节点是否为指定的数组属性
+            if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name) && node.name.text === arrayName && ts.isArrayLiteralExpression(node.initializer)) {
+                // 将新控制器项添加到数组中
+                const elements = [...node.initializer.elements.map(e => e.getText()), itemName];
+                // 返回更新后的数组属性节点
+                return ts.factory.updatePropertyAssignment(node, node.name, ts.factory.createArrayLiteralExpression(elements.map(e => ts.factory.createIdentifier(e))));
+            }
+            // 递归遍历子节点
+            return ts.visitEachChild(node, visitor, context);
+        }
+        // 返回更新后的源文件
+        return ts.visitNode(rootNode, visitor) as ts.SourceFile;
+    };
+}
+// 定义函数 applyTransformationsAndSave 用于应用变更并将更新保存到文件
+function applyTransformationsAndSave(
+    tree: Tree,
+    filePath: string,
+    sourceFile: ts.SourceFile,
+    transformations: Array<ts.TransformerFactory<ts.SourceFile>>
+) {
+    // 应用变更并获取更新后的源文件
+    const updatedSourceFile = ts.transform(sourceFile, transformations).transformed[0];
+    // 将更新后的文件内容写回指定路径
+    tree.overwrite(filePath, ts.createPrinter().printFile(updatedSourceFile as ts.SourceFile));
+}

import { Rule, SchematicContext, Tree, applyTemplates, url, move, apply, mergeWith, chain } from '@angular-devkit/schematics';
import { strings } from '@angular-devkit/core';
import * as path from 'path';
import { plural } from 'pluralize';
import * as ts from 'typescript';
export function generateFiles(options: any): Rule {
  return (_tree: Tree, _context: SchematicContext) => {
    const entityName = options.name;
    const title = options.path;
    const sourceTemplateRules = apply(url('./files/src'), [
      applyTemplates({
        ...options,
        ...strings,
        plural,
        entityName
      }),
      move(path.normalize(`src`)),
    ]);
    const viewsTemplateRules = apply(url('./files/views'), [
      applyTemplates({
        ...options,
        ...strings,
        plural,
        entityName,
        title
      }),
      move(path.normalize(`views`)),
    ]);
    return chain([
      mergeWith(sourceTemplateRules),
      mergeWith(viewsTemplateRules),
      updateAdminModule(entityName),
+     updateSharedModule(entityName)
    ]);
  };
}
+// 定义一个函数，用于更新 shared.module.ts 文件，添加指定实体和服务的导入以及相关的模块配置
+function updateSharedModule(entityName: string) {
+  // 返回一个操作 Tree 的函数，接收 tree 参数
+  return (tree: Tree) => {
+    // 定义 shared.module.ts 文件的路径
+    const sharedModulePath = 'src/shared/shared.module.ts';
+    // 从 Tree 中读取并解析 shared.module.ts 文件的内容，获取其 AST
+    const sourceFile = getSourceFile(tree, sharedModulePath);
+    // 如果 sourceFile 存在（即文件成功读取并解析）
+    if (sourceFile) {
+      // 获取实体名称的分类形式（PascalCase）和连字符形式（kebab-case）
+      const { classifiedName, dasherizedName } = getClassifiedAndDasherizedName(entityName);
+      // 定义要应用的更新操作，包括导入实体、服务，以及更新 providers 和 exports 数组
+      const updates = [
+        addImportToModule(classifiedName, `./entities/${dasherizedName}.entity`),  // 添加实体的导入
+        addImportToModule(`${classifiedName}Service`, `./services/${dasherizedName}.service`),  // 添加服务的导入
+        addToModuleArray(`providers`, `${classifiedName}Service`),  // 将服务添加到 providers 数组
+        addToModuleArray(`exports`, `${classifiedName}Service`),  // 将服务添加到 exports 数组
+        addToMethodArray('forFeature', classifiedName)  // 将实体添加到 TypeOrmModule.forFeature([]) 方法调用的数组中
+      ];
+      // 应用所有更新并将更改保存到 shared.module.ts 文件中
+      applyTransformationsAndSave(tree, sharedModulePath, sourceFile, updates);
+    }
+    // 返回更新后的 Tree
+    return tree;
+  };
+}
+// 定义一个函数，用于将资源名称添加到特定方法调用的数组参数中
+function addToMethodArray(methodName: string, resourceName: string): ts.TransformerFactory<ts.+SourceFile> {
+  // 返回一个用于操作 AST 的转换工厂
+  return (context: ts.TransformationContext) => (rootNode: ts.SourceFile) => {
+    // 定义访问器函数，用于遍历 AST 节点
+    function visitor(node: ts.Node): ts.Node {
+      // 检查当前节点是否为方法调用，并且该方法是我们指定的 methodName
+      if (
+        ts.isCallExpression(node) &&
+        ts.isPropertyAccessExpression(node.expression) &&
+        node.expression.name.text === methodName &&
+        node.arguments.length === 1 &&
+        ts.isArrayLiteralExpression(node.arguments[0])
+      ) {
+        // 获取原始数组中的所有元素，并添加新的资源名称
+        const elements = [...node.arguments[0].elements, ts.factory.createIdentifier(resourceName)];
+        // 更新方法调用，将新数组作为参数传递
+        return ts.factory.updateCallExpression(
+          node,
+          node.expression,
+          node.typeArguments,
+          [ts.factory.createArrayLiteralExpression(elements)]
+        );
+      }
+      // 递归遍历 AST 节点
+      return ts.visitEachChild(node, visitor, context);
+    }
+    // 返回更新后的根节点
+    return ts.visitNode(rootNode, visitor) as ts.SourceFile;
+  };
+}

function updateAdminModule(entityName: string) {
  return (tree: Tree) => {
    const adminModulePath = 'src/admin/admin.module.ts';
    const sourceFile = getSourceFile(tree, adminModulePath);
    if (sourceFile) {
      const { classifiedName, dasherizedName } = getClassifiedAndDasherizedName(entityName);
      const updates = [
        addImportToModule(`${classifiedName}Controller`, `./controllers/${dasherizedName}.controller`),
        addToModuleArray(`controllers`, `${classifiedName}Controller`)
      ];
      applyTransformationsAndSave(tree, adminModulePath, sourceFile, updates);
    }
    return tree;
  };
}
function getClassifiedAndDasherizedName(name: string) {
  const classifiedName = strings.classify(name);
  const dasherizedName = strings.dasherize(classifiedName);
  return { classifiedName, dasherizedName };
}
function getSourceFile(tree: Tree, filePath: string): ts.SourceFile | undefined {
  const content = tree.read(filePath)?.toString('utf-8');
  return ts.createSourceFile(filePath, content!, ts.ScriptTarget.Latest, true);
}
function addImportToModule(importName: string, importPath: string): ts.TransformerFactory<ts.SourceFile> {
  return (_context: ts.TransformationContext) => (rootNode: ts.SourceFile) => {
    const lastImport = rootNode.statements.filter(ts.isImportDeclaration).pop();
    const newImport = ts.factory.createImportDeclaration(
      undefined,
      ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(importName)),
      ])),
      ts.factory.createStringLiteral(importPath)
    );
    const updatedStatements = ts.factory.createNodeArray([
      ...rootNode.statements.slice(0, rootNode.statements.indexOf(lastImport!) + 1),
      newImport,
      ...rootNode.statements.slice(rootNode.statements.indexOf(lastImport!) + 1),
    ]);
    return ts.factory.updateSourceFile(rootNode, updatedStatements) as ts.SourceFile;
  };
}
function addToModuleArray(arrayName: string, itemName: string): ts.TransformerFactory<ts.SourceFile> {
  return (context: ts.TransformationContext) => (rootNode: ts.SourceFile) => {
    function visitor(node: ts.Node): ts.Node {
      if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name) && node.name.text === arrayName && ts.isArrayLiteralExpression(node.initializer)) {
        const elements = [...node.initializer.elements.map(e => e.getText()), itemName];
        return ts.factory.updatePropertyAssignment(node, node.name, ts.factory.createArrayLiteralExpression(elements.map(e => ts.factory.createIdentifier(e))));
      }
      return ts.visitEachChild(node, visitor, context);
    }
    return ts.visitNode(rootNode, visitor) as ts.SourceFile;
  };
}
function applyTransformationsAndSave(
  tree: Tree,
  filePath: string,
  sourceFile: ts.SourceFile,
  transformations: Array<ts.TransformerFactory<ts.SourceFile>>
) {
  const updatedSourceFile = ts.transform(sourceFile, transformations).transformed[0];
  tree.overwrite(filePath, ts.createPrinter().printFile(updatedSourceFile as ts.SourceFile));
}