@avleon/cli 0.0.27 → 0.0.30

package/dist/cli.js

@@ -180,12 +180,17 @@ async function run() {
                 if (args[0] == "make:controller" || args[0] == "m:c") {
                     let resource = false;
                     let rest = false;
+                    let prefix = true;
+                    let root = null;
                     if (args.some((x) => x == "-r" || x == "--resource")) {
                         resource = true;
                     }
                     if (args.some((x) => x == "-r" || x == "--rest")) {
                         rest = true;
                     }
+                    if (args.some((x) => x == "--base-path")) {
+                        prefix = false;
+                    }
                     let model = null;
                     if (args.some((x) => x == "-m" || x == "--model")) {
                         const index = args.includes("-m")
@@ -197,7 +202,17 @@ async function run() {
                         const modelName = args[index + 1];
                         model = modelName;
                     }
-                    await (0, controller_1.createController)(args[1], { force, resource, rest, model });
+                    if (args.some((x) => x == "-rt" || x == "--root")) {
+                        const index = args.includes("-rt")
+                            ? args.indexOf("-rt")
+                            : args.indexOf("--root");
+                        if (args[index + 1] == undefined) {
+                            throw new Error("Root Path not defined");
+                        }
+                        const rootPath = args[index + 1];
+                        root = rootPath;
+                    }
+                    await (0, controller_1.createController)(args[1], { force, resource, prefix, rest, model, root });
                 }
             }
         }

package/dist/controller.js

@@ -9,113 +9,84 @@ const path_1 = __importDefault(require("path"));
 const path_helper_1 = require("./helpers/path-helper");
 const promises_1 = __importDefault(require("node:fs/promises"));
 const file_helper_1 = require("./helpers/file-helper");
+const lodash_1 = require("lodash");
 function capitalize(str) {
     if (!str)
         return '';
     return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
 }
-async function createController(name, options = { force: false, resource: false, rest: false, model: null }, p) {
+function lower(str) {
+    return str.toLowerCase();
+}
+function exportNamesAndPath(input) {
+    const parts = input.split('/');
+    const lastPart = parts.pop();
+    const filePath = parts.length ? parts.join('/') + '/' : '.';
+    // Normalize base name by removing trailing "Controller" (case-insensitive)
+    const rawName = lastPart.replace(/controller$/i, '');
+    // Create className in PascalCase + Controller
+    const className = (0, lodash_1.upperFirst)((0, lodash_1.camelCase)(rawName));
+    // Create fileName in kebab-case + .controller.ts
+    const fileName = `${(0, lodash_1.kebabCase)(rawName)}.controller.ts`;
+    return { className, fileName, filePath };
+}
+const controllersStubs = {
+    basic: path_helper_1.pathHelper.stubPath('controllers/basic-controller.stub'),
+    rest: path_helper_1.pathHelper.stubPath('controllers/basic-controller.stub'),
+    ormRest: path_helper_1.pathHelper.stubPath('controllers/orm-rest-controller.stub')
+};
+async function createController(name, options = { force: false, resource: false, prefix: true, rest: false, model: null, root: null }, p) {
     if (!name) {
         throw new Error("Controller name not found. use --name or npx avleon make:controller HomeController");
     }
-    let stubPath = path_helper_1.pathHelper.stubPath('controllers/basic-controller.stub');
+    // determine stub for generate
+    let stubPath = controllersStubs.basic;
     if (options.rest) {
-        stubPath = path_helper_1.pathHelper.stubPath('controllers/rest-controller.stub');
+        stubPath = controllersStubs.rest;
+        if (options.model) {
+            stubPath = controllersStubs.ormRest;
+        }
     }
+    // determine root path for create controller file 
+    const rootPath = options.root ? 'src/' + options.root + '/' : 'src/controllers/';
+    // ensure file create directory exits 
     if (name.split("/").length > 1) {
-        if (!(0, fs_1.existsSync)(path_1.default.join('src/controllers/', name.split("/").splice(-1, 1).join("/")))) {
-            await promises_1.default.mkdir(path_1.default.join('src/controllers/', name.replace('/' + file_helper_1.fh.filenameFromPath(name), '')), { recursive: true });
+        if (!(0, fs_1.existsSync)(path_1.default.join(rootPath, name.split("/").splice(-1, 1).join("/")))) {
+            await promises_1.default.mkdir(path_1.default.join(rootPath, name.replace('/' + file_helper_1.fh.filenameFromPath(name), '')), { recursive: true });
         }
     }
+    // read stub content from stub file
     const content = await promises_1.default.readFile(stubPath, 'utf8');
     const names = (0, file_helper_1.resolveNames)(file_helper_1.fh.filenameFromPath(name), 'Controller');
-    const replacedContent = content
-        .replaceAll('{Controller}', names.className)
+    const className = names.className.replace("Controller", '');
+    if (options.model) {
+        await createRestService(className, options.model);
+    }
+    let replacedContent = content
+        .replaceAll('{Controller}', className)
         .replaceAll('{controller}', names.varName);
-    console.log('replce', content);
-    await promises_1.default.writeFile(path_1.default.join('src/controllers/', name + '.controller.ts'), replacedContent, 'utf8');
-    // const controllerPath = path.join(process.cwd(), "./src/controllers");
-    // const controllerFolderExists = existsSync(controllerPath);
-    // if (!controllerFolderExists) {
-    //   await mkdir(controllerPath, {
-    //     recursive: true,
-    //   });
-    // }
-    // const controllerName = name.at(0).toUpperCase() + name.slice(1);
-    // const controllerNameLowerCase = name
-    //   .replace(/Controller/ig, '')
-    //   .match(/[A-Z]?[a-z]+|[0-9]+/g) // added ? to also capture single lowercase words
-    //   ?.join('-')
-    //   .toLowerCase() || name.toLowerCase();
-    // const controllerNameCap = controllerName.replace(/Controller/ig, '')
-    // const controllerExists = existsSync(`${controllerPath}/${name.toLowerCase()}.controller.ts`);
-    // if (controllerExists && !options.force) {
-    //   console.log(
-    //     chalk.bold(chalk.red("controller already exists!")),
-    //     chalk.greenBright("Use -f or --force to overwrite.\r"),
-    //   );
-    //   return;
-    // }
-    // if (options.resource && !options.model) {
-    //   console.log(
-    //     chalk.bold(chalk.red("Model must be provide to generate rest controller!")),
-    //     chalk.greenBright("Use -m Model or --model Model to .\r"),
-    //   );
-    //   return;
-    // }
-    // const restController = `
-    // import { ApiController, Collection, Get, Post, Put, Delete, Param, Body } from '@avleon/core';
-    // import { ${capitalize(options.model)} } from '../models/${capitalize(options.model)}'
-    // \t
-    //   @ApiController("/${controllerNameLowerCase}s")
-    //   export class ${controllerName}Controller {\n
-    //   constructor(
-    //     private readonly ${options.model.toLowerCase()}Repository = Collection.fromRepository(${capitalize(options.model)})
-    //   ){}
-    // @Get()
-    // async findAll(){
-    //   return "okay";
-    // }\n
-    // @Get('/:id')
-    // async findOne(@Param('id') id:number){
-    //   return "okay";
-    // }\n
-    // @Post()
-    // async create(@Body() body:any){
-    // return true;
-    // }\n
-    // @Put('/:id')
-    // async update(@Param('id') id:number, @Body() body:any){
-    // return true;
-    // }\n
-    // @Delete('/:id')
-    // async delete(@Param('id') id:number){
-    // return true;
-    // }
-    // }
-    // `;
-    // const basicContorller = `import {ApiController, Get} from '@avleon/core'
-    // \n 
-    // @ApiController("/${controllerNameLowerCase}")
-    // export class ${controllerName}{
-    // \n
-    // @Get()
-    // index(){
-    // return []
-    // }
-    // }
-    // `;
-    // const formatcontroller = await prettier.format(
-    //   options.resource ? restController : basicContorller,
-    //   {
-    //     singleQuote: true,
-    //     singleAttributePerLine: true,
-    //     parser: "typescript",
-    //   },
-    // );
-    // await writeFile(
-    //   path.join(process.cwd(), "./src/controllers/" + controllerName.toLowerCase().replace("controller", "") + ".controller" + ".ts"),
-    //   formatcontroller,
-    // );
+    if (options.model) {
+        replacedContent = replacedContent
+            .replaceAll('{Model}', capitalize(options.model))
+            .replaceAll('{model}', lower(options.model));
+    }
+    if (!options.prefix) {
+        replacedContent = replacedContent.replace(/@ApiController\s*\(([^)]*)\)/g, '@ApiController');
+    }
+    await promises_1.default.writeFile(path_1.default.join(rootPath, (0, file_helper_1.getFilePathWithoutName)(name) + "/" + (0, lodash_1.kebabCase)(className) + '.controller.ts'), replacedContent, 'utf8');
     console.log("Controller created succssessfully!");
 }
+async function createRestService(name, model) {
+    let stubPath = path_helper_1.pathHelper.stubPath('services/rest-service.stub');
+    const content = await promises_1.default.readFile(stubPath, 'utf8');
+    const names = (0, file_helper_1.resolveNames)(file_helper_1.fh.filenameFromPath(name), 'Controller');
+    let replacedContent = content
+        .replaceAll('{Service}', name);
+    if (model) {
+        replacedContent = replacedContent
+            .replaceAll('{Model}', capitalize(model))
+            .replaceAll('{model}', lower(model));
+    }
+    await promises_1.default.writeFile(path_1.default.join('src/services/', (0, lodash_1.kebabCase)(name) + '.service.ts'), replacedContent, 'utf8');
+    console.log("Service created succssessfully!");
+}

package/dist/create.js

@@ -41,8 +41,22 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const paths_1 = require("./paths");
 const prettier = __importStar(require("prettier"));
 const win32_1 = __importDefault(require("path/win32"));
+const inquirer_1 = __importDefault(require("inquirer"));
+async function askForPackageManager() {
+    const { packageManager } = await inquirer_1.default.prompt([
+        {
+            type: 'list',
+            name: 'packageManager',
+            message: 'Which package manager do you want to use?',
+            choices: ['npm', 'yarn', 'pnpm'],
+            default: 'npm'
+        }
+    ]);
+    return packageManager;
+}
 async function createApplication(fname, flags = {}) {
     let appPaths = (0, paths_1.appPaths)(fname);
+    const pm = await askForPackageManager();
     const dirs = Object.values(appPaths);
     for (let i = 0; i < dirs.length; i++) {
         await fs_extra_1.default.ensureDir(dirs[i]);
@@ -96,7 +110,7 @@ serve();
     const packageJson = `
 {
   "name": "${fname}",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "description": "Basic avleon application",
   "main": "index.js",
   "scripts": {
@@ -131,7 +145,7 @@ serve();
     "jest": {
     "preset": "ts-jest",
     "rootDir": "src",
-    "testRegex": ".*\\.spec\\.ts$",
+    "testRegex": ".*/\/\.spec/\/\.ts$",
     "collectCoverageFrom": [
       "**/*.(t|j)s"
     ],
@@ -173,7 +187,7 @@ serve();
   "testEnvironment": "node",
   "testRegex": ".e2e-spec.ts$",
   "transform": {
-    "^.+\\.(t|j)s$": "ts-jest"
+    "^.+/\/\.(t|j)s$": "ts-jest"
   }
 }`, { parser: "json" });
     await fs_extra_1.default.writeFile(win32_1.default.join(appPaths.root, "test/e2e-spec.json"), e2eJson);
@@ -181,8 +195,8 @@ serve();
     // create basic service
     // create basic controller
     console.info("App created successfully. Run the following command to get start.");
-    console.log(`cd ${fname} && pnpm install`);
-    console.log(`npm run start:dev`);
+    console.log(`cd ${fname} && ${pm} install`);
+    console.log(pm == 'npm' ? `npm run start:dev` : `${pm} start:dev`);
     //execSync(`cd ${fname} && pnpm install && pnpm add @avleon/core`, { stdio: 'inherit' })
     console.info("Enjoy :D");
 }

package/dist/helpers/file-helper.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fh = void 0;
 exports.getLastPart = getLastPart;
+exports.getFilePathWithoutName = getFilePathWithoutName;
 exports.resolveNames = resolveNames;
 const filenameFromPath = (fpath) => fpath.split('/')[fpath.split('/').length - 1];
 function getLastPart(str, separator) {
@@ -10,6 +11,14 @@ function getLastPart(str, separator) {
     const parts = str.split(separator);
     return parts.at(-1);
 }
+function getFilePathWithoutName(fpath) {
+    const parts = fpath.split("/");
+    if (parts.length < 2) {
+        return "";
+    }
+    parts.splice(parts.length - 1, 1);
+    return parts.join("/");
+}
 function resolveNames(name, exclude) {
     const parsedName = name.replace(exclude, '');
     return {

package/dist/paths.js

@@ -25,8 +25,7 @@ const appPaths = (rootPath) => {
         controllers: node_path_1.default.join(root, "src/controllers"),
         models: node_path_1.default.join(root, "src/models"),
         services: node_path_1.default.join(root, "src/services"),
-        requests: node_path_1.default.join(root, "src/requests"),
-        responses: node_path_1.default.join(root, "src/responses"),
+        dtos: node_path_1.default.join(root, "src/dtos"),
         configs: node_path_1.default.join(root, "src/configs")
     };
 };

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@avleon/cli",
-  "version": "0.0.27",
+  "version": "0.0.30",
   "bin": {
-    "avleon": "./dist/cli.js",
-    "av":"./dist/cli.js"
+    "avleon": "./dist/cli.js"
   },
   "description": "",
   "main": "dist/index.js",
@@ -32,6 +31,7 @@
     "chalk": "^5.4.1",
     "cli-table3": "^0.6.5",
     "fs-extra": "^11.2.0",
+    "inquirer": "^12.6.0",
     "lodash": "^4.17.21",
     "prettier": "^3.3.3",
     "rimraf": "^6.0.1"

package/stubs/controllers/basic-controller.stub

@@ -2,7 +2,7 @@ import { ApiController, Get, HttpResponse } from '@avleon/core';
 
 
 @ApiController('/{controller}s')
-export class {Controller}{
+export class {Controller}Controller{
 
   @Get()
   index(){

package/stubs/controllers/orm-rest-controller.stub

@@ -0,0 +1,52 @@
+import { ApiController, Get, Post, Delete, Param, Query, Body, HttpExceptions } from '@avleon/core';
+import { {Model}Service } from '../services/{model}.service';
+
+@ApiController('/{controller}s')
+export class {Controller}Controller{
+
+  constructor(
+    private readonly {model}Service: {Model}Service
+  ){}
+
+  @Get()
+  async index(@Query() query?:any){
+    if(query && query.page){
+      const result = await this.{model}Service.paginate(query.page);
+      return result;
+    }
+    const result = await this.{model}Service.findAll();
+    return result;
+  }
+
+  @Get('/:id')
+  async findOne(@Param('id') id:number){
+    const is{Model} = await this.{model}Service.findByPk(id);
+    if(!is{Model}) throw HttpExceptions.notFound("{Model} not found.");
+    return is{Model};
+  }
+
+  @Post()
+  async create(@Body() body:any){
+    const isSave = await this.{model}Service.create(body);  
+    return isSave;
+  }
+
+  @Post('/:id')
+  async update(@Param('id') id:number, updateBody:any){
+    const is{Model} = await this.{model}Service.findByPk(id);
+    if(!is{Model}) throw HttpExceptions.notFound("{Model} not found.");
+    const isUpdated = await this.{model}Service.update(id,updateBody);
+    if(!isUpdated) throw HttpExceptions.internalError("Can't update {Model}");
+    return "Updated Successfully";
+  }
+
+  @Delete('/:id')
+  async delete(@Param('id') id:number){
+    const is{Model} = await this.{model}Service.findByPk(id);
+    if(!is{Model}) throw HttpExceptions.notFound("{Model} not found.");
+    const isDeleted = await this.{model}Service.delete(id);
+    if(!isDeleted) throw HttpExceptions.internalError("Can't delete");
+    return "Deleted Successfully";
+  }
+
+}

package/stubs/controllers/rest-controller.stub

@@ -1,32 +1,34 @@
-import { ApiController, Get, Post, Update, Delete, Param, Body, HttpResponse } from '@avleon/core';
-
+import { ApiController, Get, Post, Delete, Param, Query, Body, HttpExceptions } from '@avleon/core';
 
 @ApiController('/{controller}s')
-export class {Controller}{
+export class {Controller}Controller{
+
+  
 
   @Get()
-  index(){
-    return HttpResponse.Ok("{Controller}");
+  async index(@Query() query?:any){
+    throw new Error("Method not implemented.");
   }
 
   @Get('/:id')
-  findOne(@Param('id') id:{pktype}){
-    return HttpResponse.Ok(`Item found with id:${id}`);
+  async findOne(@Param('id') id:number){
+    throw new Error("Method not implemented.");
   }
 
   @Post()
-  create(@Body() body:{bodyType}){
-    return HttpResponse.Ok("Created");
+  async create(@Body() body:any){
+    throw new Error("Method not implemented.");
   }
 
-  @Update('/:id')
-  update(@Param('id') id:{pktype}, updateBody:{updateBodyType}){
-    return HttpResponse.Ok(`Item updated with id:${id}`)
+  @Post('/:id')
+  async update(@Param('id') id:number, updateBody:any){
+
+    throw new Error("Method not implemented.");
   }
 
   @Delete('/:id')
-  delete(@Param('id') id:{pktype}){
-    return HttpResponse.Ok(`Item delted with id:${id}`)
+  async delete(@Param('id') id:number){
+    throw new Error("Method not implemented.");
   }
 
 }

package/stubs/services/rest-service.stub

@@ -1,34 +1,73 @@
-import { AppService, Collection } from '@avleon/core';
+import { AppService, InjectRepository } from '@avleon/core';
+import { Repository } from 'typeorm';
+import { {Model} } from '../models/{model}.model';
+
 
 @AppService
-export class {Service}{
+export class {Service}Service{
 
   constructor(
-    private readonly {modelRepository}:Collection.fromRepository({Model})
-  )
+    @InjectRepository({Model})
+    private readonly {model}Repository:Repository<{Model}>
+  ){}
+
+  async findAll(options:any={}){
+    return this.{model}Repository.find(options); 
+  }
+
+  async paginate(current:number = 1, options:any={}){
+    const take = 10;
+    const skip = current >  1 ? ( current -1 ) * 10 : 0;
+    const total = await this.{model}Repository.count(options);
+    const totalPage = Math.ceil(total / take);
+    const next = current < totalPage ? current + 1 : null;
+    const prev = current > 1 ? current - 1 : null;
+    const data = await this.{model}Repository.find({
+        ...options,
+        take,
+        skip
+    })
+
+    return {
+        total,
+        totalPage,
+        current,
+        next,
+        prev,
+        data
+    };
+  }
 
-  findAll(options?:any){
-    if(options && options.page){
-      return this.{modelRepository}.paginate(options.page)
-    }
-    return this.{modelRepository}.find(); 
+  async findByPk(id:number){
+    return this.{model}Repository.findOne({id});
   }
 
-  findOne(id:{pktype}){
-    return this.{modelRepository}.findOne({where:{id}}) ;
+  async findBy(options:any){
+    return this.{model}Repository.findBy(options);
+  }
+
+  async findOneBy(options:any){
+    return this.{model}Repository.findOneBy(options);
+  }
+
+
+  async findOne(id:number){
+    return this.{model}Repository.findOne({where:{id}}) ;
   }
 
-  create(createBody:{createBodyType}){
-    const newItem = this.{modelRepository}.create();
-    return await this.{modelRepository}.save();
+  async create(createBody:any){
+    const newItem = this.{model}Repository.create();
+    return await this.{model}Repository.save();
   }
 
-  update(id:{pktype}, updateBody:{updateBodyType}){
-    return this.{modelRepository}.update({id}, updateBody); 
+  async update(id:number, updateBody:any){
+    const isUpdate = await this.{model}Repository.update({id}, updateBody); 
+    return isUpdate.affected > 0;
   }
 
-  delete(id:{pktype}){
-    return this.modelRepository.delete({id});
+  async delete(id:number){
+    const isDeleted = await this.{model}Repository.delete({id});
+    return isDeleted.affected > 0;
   }
 
 }