@avleon/cli 0.0.1 → 0.0.2

package/dist/av-cli.js

@@ -1,8 +1,7 @@
+#!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cli = void 0;
 exports.PathExtractor = PathExtractor;
-const commands_1 = require("./commands");
 function formatFileName(name) {
     return name
         .replace(/[_\s]+/g, "-")
@@ -59,35 +58,3 @@ function PathExtractor(givenPath, options) {
     let outputPath = givenPath + "." + fileType + ".ts";
     return {};
 }
-class Cli {
-    constructor() {
-        this.commands = commands_1.commandList;
-        this.isBusy = false;
-    }
-    createApplication() { }
-    createModel(options) {
-        throw new Error("Method not implemented.");
-    }
-    createService() {
-        throw new Error("Method not implemented.");
-    }
-    createController() {
-        throw new Error("Method not implemented.");
-    }
-    createProject() {
-        throw new Error("Method not implemented.");
-    }
-    createResource() {
-        throw new Error("Method not implemented.");
-    }
-    createRestService() {
-        throw new Error("Method not implemented.");
-    }
-    createRestController() {
-        throw new Error("Method not implemented.");
-    }
-    displayHelp() {
-        throw new Error("Method not implemented.");
-    }
-}
-exports.Cli = Cli;

package/dist/cli.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;

package/dist/controller.js

@@ -70,9 +70,7 @@ async function createController(name, options = { force: false, resource: false,
     const restController = `
   import { ApiController, Get, Post, Put, Delete, Param, Body } from '@avleon/core';
   \t
-    @ApiController("/${controllerNameLowerCase}", { 
-      name: "${controllerNameCap}" 
-    })
+    @ApiController("/${controllerNameLowerCase}")
     export class ${controllerName}{\n
   @Get()
   async findAll(){
@@ -103,7 +101,7 @@ async function createController(name, options = { force: false, resource: false,
   export class ${controllerName}{
   \n
   @Get()
-  async index(){
+  index(){
   return []
   }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avleon/cli",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "bin": {
     "av": "./dist/cli.js"
   },

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 };

package/src/create.ts

@@ -0,0 +1,117 @@
+
+import fs from 'fs-extra';
+import { appPaths as getAppPaths } from './paths';
+import * as prettier from 'prettier';
+import path from 'path/win32';
+import { execSync } from 'child_process';
+
+
+
+async function createApplication(fname: any) {
+
+  const appPaths = getAppPaths(fname);
+  const dirs = Object.values(appPaths);
+  for (let i = 0; i < dirs.length; i++) {
+    await fs.ensureDir(dirs[i]);
+  }
+
+  await fs.ensureDir(appPaths.root + "/public");
+  // copy 
+  //
+  const mainFunc = `
+import 'reflect-metadata';
+import { AppBuilder } from '@avleon/core';
+
+async function main() {
+  const builder = AppBuilder.createBuilder();
+//  builder.useLogger();
+  builder.useDatabase();
+
+  const app = await builder.build();
+  await app.mapControllers();
+  await app.run();
+
+}
+main().catch(err=> console.log(err));
+`
+
+  const formatMainFunc = await prettier.format(
+    mainFunc,
+    {
+      singleQuote: true,
+      singleAttributePerLine: true,
+      parser: "typescript",
+    },
+  );
+
+  await fs.writeFile(path.join(appPaths.src, 'app.ts'), formatMainFunc);
+
+  // create package.json
+  const packageJson = `
+{
+  "name": "${fname}",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \\"Error: no test specified\\" && exit 1",
+    "dev": "nodemon src/app.ts",
+    "start": "node dist/app.js",
+    "build": "rimraf dist && tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
+    "reflect-metadata": "^0.2.2"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.7",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.7.2"
+  }
+
+}
+`
+
+  const formattedPackageJson = await prettier.format(
+    packageJson,
+    {
+      parser: "json",
+    },
+  );
+  await fs.writeFile(path.join(appPaths.root, 'package.json'), formattedPackageJson);
+  const tsconfigJson = await prettier.format(`{
+  "compilerOptions": {
+    "target": "ES2017",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}`, { parser: 'json' })
+  await fs.writeFile(path.join(appPaths.root, 'tsconfig.json'), tsconfigJson);
+  await fs.writeFile(path.join(appPaths.root, '.gitignore'), `node_modules/\ndist/\n.env`);
+  // create basic service
+  // create basic controller
+
+
+  console.info("Running pnpm install");
+  execSync(`cd ${fname}&& pnpm install && pnpm link @avleon/core && pnpm link @avleon/data`, { stdio: 'inherit' })
+
+  console.info("App create successfully.");
+
+
+}
+
+
+
+export { createApplication }

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./cli";

package/src/paths.ts

@@ -0,0 +1,29 @@
+import path from "node:path";
+
+export type AppPaths = {
+  root: string,
+  src: string,
+  test: string,
+  controllers: string,
+  models: string,
+  services: string,
+  requests: string,
+  responses: string,
+  configs: string
+}
+
+
+export const appPaths = (rootPath?: string): AppPaths => {
+  const root = rootPath ? rootPath : path.join(process.cwd(), "./");
+  return {
+    root: root,
+    src: path.join(root, "src"),
+    test: path.join(root, "test"),
+    controllers: path.join(root, "src/controllers"),
+    models: path.join(root, "src/models"),
+    services: path.join(root, "src/services"),
+    requests: path.join(root, "src/requests"),
+    responses: path.join(root, "src/responses"),
+    configs: path.join(root, "src/configs")
+  }
+}

package/src/stubs/basic-controller.stub

@@ -0,0 +1,7 @@
+import { Get, HttpResponse } from '@avleon/core'; 
+export class {{name}}{
+    constructor(
+      private readonly {}
+    ){}
+}
+