@avleon/cli 0.0.1 → 0.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avleon/cli",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "bin": {
     "av": "./dist/cli.js"
   },
@@ -13,24 +13,24 @@
     "clean": "rm -rf ./dist",
     "watch": "tsc-watch"
   },
-  "keywords": [],
-  "author": "",
+  "keywords": ["cli","backend-api"],
+  "author": "Tareq Hossain",
   "license": "ISC",
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^22.9.3",
-    "cli-table3": "^0.6.5",
     "nodemon": "^3.1.7",
-    "prettier": "^3.3.3",
     "tsc-watch": "^6.2.1",
     "typescript": "^5.7.2"
   },
   "dependencies": {
     "chalk": "^4",
+    "prettier": "^3.3.3",
+    "cli-table3": "^0.6.5",
     "fs-extra": "^11.2.0"
   },
-    "repository": {
-      "type": "git",
-      "url": "git+https://github.com/avleonjs/avleon-cli"
-    }
-}
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/avleonjs/avleon-cli"
+  }
+}

package/readme.md

@@ -1,3 +1,4 @@
 # Avleon CLI
 
 
+Coming Soon....

package/src/av-cli.ts

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import { AvCli, CreateModelOptions } from "./cli.interface";
+import { commandList, CommandType } from "./commands";
+
+type ProjectFileType =
+  | "controller"
+  | "service"
+  | "model"
+  | "util"
+  | "helper"
+  | "config";
+
+interface FilePathExtractor {
+  name: string;
+  ext?: string;
+  parent: string;
+  givenPath: string;
+  outputPath?: string;
+  newFileName: string;
+  className: string;
+  exsits: boolean;
+  force: boolean;
+  fileType?: ProjectFileType;
+}
+
+function formatFileName(name: string) {
+  return name
+    .replace(/[_\s]+/g, "-")
+    .replace(/([a-z])([A-Z])/g, "$1-$2")
+    .replace(
+      /((-|_|\.)+(Controller|Service|Model))|(Controller|Service|Model)/gi,
+      "",
+    )
+    .toLowerCase();
+}
+
+function formatClassName(name: string) {
+  return name
+    .replace(/[_\s-]+/g, " ")
+    .replace(/([a-z])([A-Z])/g, "$1 $2")
+    .toLowerCase()
+    .replace(/\b\w/g, (char) => char.toUpperCase())
+    .replace(/\s+/g, "");
+}
+
+export function PathExtractor(givenPath: string, options: string[]) {
+  let pathSplits = givenPath.split("/");
+  let splitSize = pathSplits.length;
+  let hasSubDirectory = splitSize > 0;
+  let name = hasSubDirectory ? pathSplits[splitSize - 1] : pathSplits[0];
+  let className = formatClassName(name);
+  let fileType = "any";
+  let isRest = false;
+  let isForced = false;
+  if (options.includes("make:controller") || options.includes("m:c")) {
+    fileType = "controller";
+    className = name.toLowerCase().replace(/controller|Controller/g, "");
+  }
+  if (options.includes("make:model") || options.includes("m:m")) {
+    fileType = "model";
+    className = name.toLowerCase().replace(/controller|Controller/g, "");
+  }
+
+  if (options.includes("make:service") || options.includes("m:s")) {
+    fileType = "service";
+    className = name.toLowerCase().replace(/controller|Controller/g, "");
+  }
+
+  if (options.includes("make:util") || options.includes("m:u")) {
+    fileType = "util";
+    className = name.toLowerCase().replace(/controller|Controller/g, "");
+  }
+
+  if (options.includes("make:config")) {
+    fileType = "config";
+    className = name.toLowerCase().replace(/controller|Controller/g, "");
+  }
+
+  if (options.includes("--rest") || options.includes("-r")) {
+    isRest = true;
+    className = name.toLowerCase().replace(/controller|Controller/g, "");
+  }
+
+  if (options.includes("--force") || options.includes("-f")) {
+    isForced = true;
+    className = name.toLowerCase().replace(/controller|Controller/g, "");
+  }
+
+  let outputFileName = formatFileName(name);
+
+  let outputPath = givenPath + "." + fileType + ".ts";
+
+  return {};
+}
+

package/src/cli.interface.ts

@@ -0,0 +1,55 @@
+import { CommandType } from "./commands";
+
+export interface AvCli {
+  commands: CommandType[];
+
+  createModel(): void;
+  createService(): void;
+  createController(): void;
+  createProject(): void;
+  createResource(): void;
+  createRestService(): void;
+  createRestController(): void;
+  displayHelp(): void;
+}
+
+type BaseBuildOptions = {
+  force: boolean;
+};
+
+export type CreateModelOptions = {
+  orm: boolean; //default false
+  timestamps: boolean; // timestamp true
+  fields: any;
+} & BaseBuildOptions;
+
+export type CreateControllerOptions = {
+  service: Function;
+  model: Function;
+  rest: boolean;
+} & BaseBuildOptions;
+
+export type CreateServiceOptions = {
+  model: Function;
+  rest: boolean;
+  orm: boolean;
+} & BaseBuildOptions;
+
+export type CreateApplicationOptions = {
+  orm: boolean;
+  minimal: boolean;
+} & BaseBuildOptions;
+
+export interface IBuilder {
+  content: string;
+  parse(content: string): IBuilder;
+  process(content: string): IBuilder;
+  format(content: string, parseOptions: any): IBuilder;
+  build(): string;
+}
+
+export interface ModelBuilder extends IBuilder {}
+export interface ProjectBuilder extends IBuilder {}
+export interface ControllerBuilder extends IBuilder {}
+export interface ServiceBuilder extends IBuilder {}
+export interface ResourceBuilder extends IBuilder {}

package/src/cli.ts

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+import Table, { HorizontalTableRow } from "cli-table3";
+import path from "path";
+import fs from "fs/promises";
+import fsExtra from 'fs-extra';
+import { existsSync } from "fs";
+import * as prettier from "prettier";
+import chalk from "chalk";
+import { createController } from "./controller";
+import { commandList } from "./commands";
+import { exec, execSync } from "child_process";
+import { createApplication } from "./create";
+
+export function iqraCli() { }
+
+const listedCommands = commandList.flatMap(x => x.Command).concat(commandList.flatMap(x => x.Alias.split(","))).flatMap(a => a.trim());
+
+/**
+ * @description Displaying basic info
+ * @since v0.0.2
+ * */
+async function printLogo() {
+  try {
+    const packageInfo = await fs.readFile(
+      path.join(__dirname, "../package.json"),
+      "utf8",
+    );
+    const parsedPackInfo = JSON.parse(packageInfo);
+    console.log(`Name: Avleon CLI`, "\r");
+    console.log(`Version: ${parsedPackInfo.version}`, "\r");
+  } catch (error) {
+    throw new Error("Can't read packag info");
+  }
+}
+
+async function displayCommandList(info = { logo: true, all: false }) {
+  if (info.logo) {
+    await printLogo();
+  }
+  console.log("Available commandList:");
+
+  if (info.all) {
+    const table = new Table({
+      head: ["Command", "Alias", "Available Options", "Description"],
+      colWidths: [20, 10, 30, 50],
+      wrapOnWordBoundary: true,
+      wordWrap: true,
+    });
+    commandList.forEach((c) => {
+      table.push([c.Command, c.Alias, c.Options, c.Description]);
+    });
+    console.log(table.toString());
+  } else {
+    const table = new Table({
+      head: ["Command", "Alias", "Available Options"],
+      colWidths: [20, 10, 50],
+      wrapOnWordBoundary: true,
+      wordWrap: true,
+    });
+    commandList.forEach((c) => {
+      table.push([c.Command, c.Alias, c.Options]);
+    });
+    console.log(table.toString());
+  }
+
+}
+
+async function createModel(name: string, options = { force: false }) {
+  if (!name) {
+    throw new Error(
+      "Model name not found . use --name or node artisan make:model ModelName",
+    );
+  }
+
+  const modelFolderExists = existsSync(
+    path.join(process.cwd(), "./src/models"),
+  );
+  if (!modelFolderExists) {
+    await fs.mkdir(path.join(process.cwd(), "./src/models"), {
+      recursive: true,
+    });
+  }
+
+  const modelName = name.at(0).toUpperCase() + name.slice(1);
+  const modelExists = existsSync(
+    path.join(process.cwd(), `./src/models/${modelName.toLowerCase()}.ts`),
+  );
+
+  if (modelExists && !options.force) {
+    console.log(
+      chalk.bold(chalk.red("Model already exists!")),
+      chalk.greenBright("Use -f or --force to overwrite.\r"),
+    );
+    return;
+  }
+
+  const model = `
+import {Entity, PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn } from 'typeorm';
+\t
+  @Entity({name:'${modelName}'})
+  export class ${modelName}{
+
+  @PrimaryGeneratedColumn()
+  id:number;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+}
+`;
+
+  const formatModel = await prettier.format(model, {
+    singleQuote: true,
+    singleAttributePerLine: true,
+    parser: "typescript",
+  });
+
+  await fs.writeFile(
+    path.join(process.cwd(), "./src/models/" + modelName.toLowerCase() + ".ts"),
+    formatModel,
+  );
+
+  console.log("Model created succssessfully!");
+}
+
+async function createXApplication(fname: string) {
+  if (existsSync(process.cwd() + fname)) {
+    throw new Error("Application already exists");
+  }
+
+
+  const projectPath = path.join(process.cwd(), fname);
+  const templateDir = path.resolve("D:\\projects\\node\\iqra\\packages\\cli\\src\\stubs");
+
+  //await fs.mkdir(projectPath);
+
+  //await fsExtra.copy(templateDir, projectPath + '/'); 
+
+
+  // Define project path
+  // const projectPath = path.resolve('new_test');
+
+  // Clone the repository and move the required folder
+  const cloneCommand = `
+git clone -n --depth=1 --filter=tree:0 https://github.com/xtareq/iqra temp_repo &&
+cd temp_repo &&
+git sparse-checkout init --no-cone &&
+git sparse-checkout set examples/iqra_test &&
+git checkout &&
+mv examples/iqra_test ${projectPath} &&
+cd ..
+`;
+
+  try {
+    // Execute the cloning and moving process
+    console.log('Cloning and setting up the repository...');
+    exec(cloneCommand, {});
+
+    // Check if the projectPath exists before proceeding
+    if (!fsExtra.existsSync(projectPath)) {
+      throw new Error(`Project path "${projectPath}" was not created.`);
+    }
+
+    // Remove the Git origin from the new project
+    console.log('Removing Git origin...');
+    execSync(`cd ${projectPath} && git remote remove origin`, { stdio: 'inherit' });
+
+    // Clean up the temporary repository
+    console.log('Cleaning up temporary files...');
+    fsExtra.removeSync('./temp_repo');
+
+    console.log(`Project created successfully in ${projectPath}`);
+  } catch (error) {
+    console.error('An error occurred:', error);
+
+    // Cleanup in case of failure
+    if (fsExtra.existsSync('./temp_repo')) {
+      console.log('Cleaning up temporary repository...');
+      fsExtra.removeSync('./temp_repo');
+    }
+    if (fsExtra.existsSync(projectPath)) {
+      console.log('Cleaning up project path...');
+      fsExtra.removeSync(projectPath);
+    }
+  }
+
+}
+
+export async function run() {
+  try {
+    const args = process.argv.slice(2);
+    if (args.length < 1) {
+      await displayCommandList({ logo: true, all: false });
+    } else {
+      const cmdList = commandList
+        .flatMap((x) => x.Command)
+        .concat(
+          ...commandList.flatMap((f) => f.Alias.split(",").map((s) => s.trim())),
+        );
+      if (!listedCommands.includes(args[0].trim())) {
+        console.error("Invalid command");
+        await displayCommandList({ logo: false, all: false });
+      } else {
+        let force = false;
+        if (args.some((x) => x == "-f" || x == "--force")) {
+          force = true;
+        }
+        if (args[0] == "new") {
+          const fname = args[1];
+          await createApplication(fname);
+        }
+        if (args[0] == "make:model") {
+          await createModel(args[1], { force });
+        }
+        if (args[0] == "make:controller" || args[0] == "m:c") {
+          let resource = false;
+          if (args.some((x) => x == "-r" || x == "--resource")) {
+            resource = true;
+          }
+          let model = null;
+          if (args.some((x) => x == "-m" || x == "--model")) {
+            const index = args.includes("-m")
+              ? args.indexOf("-m")
+              : args.indexOf("--model");
+            if (args[index + 1] == undefined) {
+              throw new Error("Model not defined");
+            }
+            const modelName = args[index + 1];
+            model = modelName;
+          }
+          await createController(args[1], { force, resource, model });
+        }
+      }
+    }
+  } catch (error) {
+    console.log("CLI ERROR:", error);
+  }
+}
+run()

package/src/commands.ts

@@ -0,0 +1,56 @@
+import chalk from "chalk";
+export type CommandType = {
+  Command: string;
+  Alias: string;
+  Options: string;
+  Description: string;
+}
+
+export const commandList: CommandType[] = [
+  {
+    Command: "new",
+    Alias: "",
+    Options: "--minimal -m, -d --database",
+    Description: "Create a new application"
+  },
+  {
+    Command: "make:model",
+    Alias: "m:m, mm",
+    Options: "-f --force",
+    Description:
+      "Create a new model. Use -f or --froce to overwrite if any model exists with name",
+  },
+  {
+    Command: "make:controller",
+    Alias: "m:c",
+    Options: `-f, --force for force create\n -r or --resource for resource controller`,
+    Description: `Create a new controller. Use -f or --force to overwrite existing controller. If you want to create a resource controller pass options -r or --resource. 
+You may also pass model by -m or --model.\n
+${chalk.blueBright("Note:")} when using a resource contorller iqra will automaticall check for dtos related to model name. If -m is user then
+it will check for dtos like UserCreateDto and UserUpdateDto. If dtos not found it will create automatically using 
+model properties.
+    `,
+  },
+  {
+    Command: "make:service",
+    Alias: "m:s",
+    Options: `-f, --force for force create\n -r or --resource for resource controller`,
+    Description: `Create a new controller. Use -f or --force to overwrite existing controller. If you want to create a resource controller pass options -r or --resource. 
+You may also pass model by -m or --model.\n
+${chalk.blueBright("Note:")} when using a resource contorller iqra will automaticall check for dtos related to model name. If -m is user then
+it will check for dtos like UserCreateDto and UserUpdateDto. If dtos not found it will create automatically using 
+model properties.
+    `,
+  },
+  {
+    Command: "make:resource",
+    Alias: "m:r",
+    Options: `-f, --force for force create\n -r or --resource for resource`,
+    Description: `Create a new resource. Use -f or --force to overwrite existing controller. If you want to create a resource controller pass options -r or --resource. 
+You may also pass model by -m or --model.\n
+${chalk.blueBright("Note:")} when using a resource contorller iqra will automaticall check for dtos related to model name. If -m is user then
+it will check for dtos like UserCreateDto and UserUpdateDto. If dtos not found it will create automatically using 
+model properties.
+    `,
+  },
+];

package/src/controller.ts

@@ -0,0 +1,106 @@
+import chalk from "chalk";
+import { existsSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import prettier from "prettier";
+
+
+async function createController(
+  name: string,
+  options = { force: false, resource: false, model: null },
+  p?: string
+) {
+  if (!name) {
+    throw new Error(
+      "Controller name not found. use --name or node artisan make:controller HomeController",
+    );
+  }
+  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).join("-").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.model) {
+    const file = await import(
+      path.join(process.cwd(), "./src/models/" + options.model.toUpperCase() + ".ts")
+    );
+
+    if (file) {
+      Object.getOwnPropertyNames(file);
+    }
+  }
+
+  const restController = `
+  import { ApiController, Get, Post, Put, Delete, Param, Body } from '@avleon/core';
+  \t
+    @ApiController("/${controllerNameLowerCase}")
+    export class ${controllerName}{\n
+  @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,
+  );
+
+  console.log("Controller created succssessfully!");
+}
+export { createController };