@devbro/pashmak 0.1.54 → 0.1.56

package/README.md

@@ -3,9 +3,9 @@
 > [!CAUTION]
 > Still in Beta. Stable to use but not fully battle tested. I expect a few more things to change. For the most part only new stuff will be added so backward compatibility is mostly guaranteed.
 
-Inspired by laravel and Rails, Pashmak is a typescript focused, ESM first framework. Pashmak was created to provide a simple and seamless way to build web applications, APIs, and services using modern JavaScript and TypeScript features. It is ideal for rapid prototyping and development of web applications, RESTful APIs, and microservices.
+Inspired by laravel and Rails, Pashmak is a typescript focused, ESM first framework that follows CUPID methodology. Pashmak was created to provide a simple and seamless way to build web applications, APIs, and services using modern JavaScript and TypeScript features. It is ideal for rapid prototyping and development of web applications, RESTful APIs, and microservices.
 
-Pashmak is designed with developer experience, rapid development and delivery in mind. It aims to provide a clean and intuitive approach so developers can focus on writing business logic rather than dealing with boilerplate code.
+Pashmak is designed with developer experience, rapid development and delivery in mind. It aims to provide a clean and intuitive approach so developers can focus on writing business logic rather than dealing with boilerplate code. With Pashmak, AI can create simple and intuitive code that needs little to no intervention and easily understood with developers.
 
 for documentation please check [documentations](https://devbro1.github.io/pashmak/)
 

package/dist/cjs/app/console/index.js

@@ -1539,13 +1539,13 @@ function normalize(strArray) {
 }
 __name(normalize, "normalize");
 function urlJoin() {
-  var input;
+  var input2;
   if (typeof arguments[0] === "object") {
-    input = arguments[0];
+    input2 = arguments[0];
   } else {
-    input = [].slice.call(arguments);
+    input2 = [].slice.call(arguments);
   }
-  return normalize(input);
+  return normalize(input2);
 }
 __name(urlJoin, "urlJoin");
 
@@ -2656,24 +2656,17 @@ var CreateProjectCommand = class extends import_clipanion10.Command {
     category: `Project`,
     description: `Create a new project`,
     details: `
-      This command creates a new project with the specified name at the given path.
-      If no path is provided, the project will be created in the current directory.
+      This command creates a new project interactively.
+      You will be prompted for the project path and other configuration options.
     `,
-    examples: [
-      [
-        `Create a new project in specified directory`,
-        `create project --path /path/to/my-project --git`
-      ],
-      [
-        `Create a new project at a specific path with git initialized`,
-        `create project --path /path/to/my-project --git`
-      ]
-    ]
-  });
-  projectPath = import_clipanion10.Option.String("--path", { required: true });
-  git = import_clipanion10.Option.Boolean(`--git`, false, {
-    description: `Initialize a git repository in the new project`
+    examples: [[`Create a new project`, `create project`]]
   });
+  projectPath = "";
+  executor = "";
+  packageManager = "";
+  linter = "";
+  validation_library = "";
+  database_type = "";
   async folderExists(folderPath) {
     try {
       const stats = await fs7.stat(folderPath);
@@ -2686,14 +2679,148 @@ var CreateProjectCommand = class extends import_clipanion10.Command {
     }
   }
   async execute() {
-    const projectPath = import_path8.default.join(this.projectPath);
-    try {
-      await fs7.access(projectPath);
-      console.error(`Error: Directory ${projectPath} already exists.`);
-      return 1;
-    } catch {
+    await this.setupProjectPath();
+    await this.setupGit();
+    await this.setupExecutorAndPackageManager();
+    await this.setupLinter();
+    await this.setupGeneralPackages();
+    await this.setupBaseProject();
+    await this.installPackages();
+  }
+  async processTplFolder(src, dest, data = {}) {
+    const files = await fs7.readdir(src, { withFileTypes: true });
+    for (const file of files) {
+      const srcPath = import_path8.default.join(src, file.name);
+      const destPath = file.isFile() && file.name.endsWith(".tpl") ? import_path8.default.join(dest, file.name.substring(0, file.name.length - 4)) : import_path8.default.join(dest, file.name);
+      if (file.isDirectory()) {
+        await fs7.mkdir(destPath, { recursive: true });
+        await this.processTplFolder(srcPath, destPath, data);
+      } else if (file.name.endsWith(".tpl")) {
+        await this.processTplFile(srcPath, destPath, data);
+      } else {
+        throw new Error(
+          "unexpected non tpl file: " + srcPath + " " + file.name
+        );
+      }
     }
-    const validation_library = await (0, import_prompts.select)({
+  }
+  async processTplFile(src, dest, data = {}) {
+    import_handlebars3.default.registerHelper("eq", (a, b) => a === b);
+    const compiledTemplate = import_handlebars3.default.compile(
+      (await fs7.readFile(src)).toString()
+    );
+    const template = await compiledTemplate(data);
+    await fs7.writeFile(dest, template);
+  }
+  async setupProjectPath() {
+    const pathInput = await (0, import_prompts.input)({
+      message: "Enter project path (leave empty to use current directory):",
+      default: ""
+    });
+    this.projectPath = pathInput.trim() ? import_path8.default.resolve(pathInput.trim()) : process.cwd();
+    await fs7.mkdir(this.projectPath, { recursive: true });
+    const files = await fs7.readdir(this.projectPath);
+    if (files.length > 0) {
+      throw new Error(
+        `Directory ${this.projectPath} is not empty. Please use an empty directory.`
+      );
+    }
+  }
+  async setupExecutorAndPackageManager() {
+    this.executor = await (0, import_prompts.select)({
+      message: "Select a TypeScript executor",
+      choices: [
+        {
+          name: "Bun",
+          value: "bun",
+          description: "Fast all-in-one JavaScript runtime"
+        },
+        {
+          name: "TSX",
+          value: "tsx",
+          description: "TypeScript execute (tsx) - Node.js enhanced with esbuild"
+        }
+      ]
+    });
+    this.packageManager = this.executor === "bun" ? "bun" : await (0, import_prompts.select)({
+      message: "Select a package manager",
+      choices: [
+        {
+          name: "Yarn",
+          value: "yarn",
+          description: "Fast, reliable, and secure dependency management"
+        },
+        {
+          name: "npm",
+          value: "npm",
+          description: "Node package manager (default)"
+        },
+        {
+          name: "Bun",
+          value: "bun",
+          description: "Ultra-fast package manager built into Bun"
+        }
+      ],
+      default: "yarn"
+    });
+    (0, import_child_process.execSync)(`${this.packageManager} init -y`, {
+      stdio: "inherit",
+      cwd: this.projectPath
+    });
+    const packageJsonPath = import_path8.default.join(this.projectPath, `package.json`);
+    let packageJson = JSON.parse(await fs7.readFile(packageJsonPath, `utf-8`));
+    packageJson.type = "module";
+    packageJson.scripts = packageJson.scripts || {};
+    packageJson.scripts.prepare = "husky init";
+    packageJson.scripts.clean = "rm -rf dist";
+    if (this.executor === "bun") {
+      packageJson.scripts.dev = "bun run dev";
+      packageJson.scripts.start = "bun run pdev";
+      packageJson.scripts.build = "bun run build";
+      packageJson.scripts.test = "vitest";
+      packageJson.scripts["test:watch"] = "vitest --watch";
+      packageJson.scripts["test:coverage"] = "vitest run --coverage";
+    } else if (this.executor === "tsx") {
+      packageJson.scripts.dev = "tsx --watch -r tsconfig-paths/register src/index.ts start --all | npx pino-pretty";
+      packageJson.scripts.start = "tsx dist/index.js";
+      packageJson.scripts.build = "tsc";
+      packageJson.scripts.test = "vitest";
+      packageJson.scripts["test:watch"] = "vitest --watch";
+      packageJson.scripts["test:coverage"] = "vitest run --coverage";
+    }
+    await fs7.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+  }
+  async setupLinter() {
+    this.linter = await (0, import_prompts.select)({
+      message: "Select a linter",
+      choices: [
+        {
+          name: "Biome",
+          value: "biome",
+          description: "Fast formatter and linter for JavaScript, TypeScript, and more"
+        },
+        {
+          name: "ESLint",
+          value: "eslint",
+          description: "Find and fix problems in your JavaScript code"
+        }
+      ]
+    });
+    const packageJsonPath = import_path8.default.join(this.projectPath, `package.json`);
+    let packageJson = JSON.parse(await fs7.readFile(packageJsonPath, `utf-8`));
+    if (this.linter === "biome") {
+      packageJson.scripts.lint = "biome check . --ext .ts,.tsx";
+      packageJson.scripts.format = "biome format . --ext .ts,.tsx --write";
+      this.addPackage("@biomejs/biome", true);
+    } else if (this.linter === "eslint") {
+      packageJson.scripts.lint = "eslint . --ext .ts,.tsx";
+      packageJson.scripts.format = "eslint . --ext .ts,.tsx --fix";
+      this.addPackage("eslint", true);
+    }
+    await fs7.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+  }
+  async setupGeneralPackages() {
+    this.validation_library = await (0, import_prompts.select)({
       message: "Select a package you want for validation",
       choices: [
         {
@@ -2714,8 +2841,42 @@ var CreateProjectCommand = class extends import_clipanion10.Command {
         }
       ]
     });
-    await fs7.mkdir(projectPath, { recursive: true });
-    console.log(`Created project directory at: ${projectPath}`);
+    this.validation_library === "none" || await this.addPackage(this.validation_library);
+    this.database_type = await (0, import_prompts.select)({
+      message: "Select a database type (you can add more databases later)",
+      choices: [
+        {
+          name: "PostgreSQL",
+          value: "postgresql",
+          description: "A powerful, open source object-relational database system"
+        },
+        {
+          name: "MySQL",
+          value: "mysql",
+          description: "The world's most popular open source database"
+        },
+        {
+          name: "SQLite",
+          value: "sqlite",
+          description: "A C library that provides a lightweight disk-based database"
+        }
+      ]
+    });
+    if (this.database_type === "postgresql") {
+      await this.addPackage("pg pg-cursor");
+    } else if (this.database_type === "mysql") {
+      await this.addPackage("mysql2");
+    } else if (this.database_type === "sqlite") {
+      await this.addPackage("sqlite3");
+    }
+    await this.addPackage("@devbro/pashmak tsconfig-paths dotenv ");
+    await this.addPackage(
+      "husky vitest supertest @types/supertest pino-pretty typescript tsx",
+      true
+    );
+  }
+  async setupBaseProject() {
+    console.log(`Using project directory: ${this.projectPath}`);
     const dirname = typeof __dirname === "undefined" ? import_path8.default.dirname((0, import_url3.fileURLToPath)(import_meta3.url)) : __dirname;
     let basePath = import_path8.default.join(dirname, `./base_project`);
     if (await this.folderExists(basePath) === false) {
@@ -2723,53 +2884,90 @@ var CreateProjectCommand = class extends import_clipanion10.Command {
     }
     console.log(`Using base project path: ${basePath}`);
     const baseProjectPath = basePath;
-    await this.processTplFolder(baseProjectPath, projectPath, {
-      validation_library
+    await this.processTplFolder(baseProjectPath, this.projectPath, {
+      validation_library: this.validation_library,
+      executor: this.executor,
+      package_manager: this.packageManager,
+      linter: this.linter,
+      database_type: this.database_type
     });
-    console.log(`Copied base project files to: ${projectPath}`);
-    const packageJsonPath = import_path8.default.join(projectPath, `package.json`);
-    const packageJson = JSON.parse(await fs7.readFile(packageJsonPath, `utf-8`));
-    packageJson.name = import_change_case_all3.Case.snake(import_path8.default.basename(projectPath));
+    console.log(`Copied base project files to: ${this.projectPath}`);
+    const packageJsonPath = import_path8.default.join(this.projectPath, "package.json");
+    let packageJson = JSON.parse(await fs7.readFile(packageJsonPath, `utf-8`));
+    packageJson.name = import_change_case_all3.Case.snake(import_path8.default.basename(this.projectPath));
     await fs7.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
     console.log(`Updated package.json with project name: ${packageJson.name}`);
-    if (this.git) {
-      try {
-        (0, import_child_process.execSync)(
-          'git init; git add --all; git commit --allow-empty -m "chore: first commit for pashmak"',
-          {
-            cwd: projectPath
-          }
-        );
-      } catch (error) {
-        console.error(`Failed to create project.`, error);
-        return 1;
-      }
-    }
   }
-  async processTplFolder(src, dest, data = {}) {
-    const files = await fs7.readdir(src, { withFileTypes: true });
-    for (const file of files) {
-      const srcPath = import_path8.default.join(src, file.name);
-      const destPath = file.isFile() && file.name.endsWith(".tpl") ? import_path8.default.join(dest, file.name.substring(0, file.name.length - 4)) : import_path8.default.join(dest, file.name);
-      if (file.isDirectory()) {
-        await fs7.mkdir(destPath, { recursive: true });
-        await this.processTplFolder(srcPath, destPath, data);
-      } else if (file.name.endsWith(".tpl")) {
-        await this.processTplFile(srcPath, destPath, data);
-      } else {
-        throw new Error(
-          "unexpected non tpl file: " + srcPath + " " + file.name
-        );
-      }
+  async addPackage(packageName, dev = false) {
+    let install_command = "";
+    switch (this.packageManager) {
+      case "bun":
+        install_command = `bun add ${packageName}${dev ? " -d" : ""}`;
+        break;
+      case "yarn":
+        install_command = `yarn add ${packageName}${dev ? " -D" : ""} --no-install`;
+        break;
+      case "npm":
+        install_command = `npm install ${packageName}${dev ? " --save-dev" : ""} --package-lock-only`;
+        break;
+    }
+    (0, import_child_process.execSync)(install_command, {
+      stdio: "inherit",
+      cwd: this.projectPath
+    });
+  }
+  async installPackages() {
+    const install_command = this.packageManager === "bun" ? `bun install` : this.packageManager === "yarn" ? `yarn` : `npm install`;
+    (0, import_child_process.execSync)(install_command, {
+      stdio: "inherit",
+      cwd: this.projectPath
+    });
+  }
+  async setupGit() {
+    const initGit = await (0, import_prompts.select)({
+      message: "Initialize a git repository?",
+      choices: [
+        {
+          name: "Yes",
+          value: true,
+          description: "Initialize git and create first commit"
+        },
+        {
+          name: "No",
+          value: false,
+          description: "Skip git initialization"
+        }
+      ]
+    });
+    if (initGit) {
+      const gitignoreContent = [
+        "node_modules/",
+        "dist/",
+        ".env",
+        ".env.*",
+        "!.env.example",
+        "*.log",
+        "coverage/",
+        ".DS_Store"
+      ].join("\n") + "\n";
+      await fs7.writeFile(
+        import_path8.default.join(this.projectPath, ".gitignore"),
+        gitignoreContent
+      );
+      (0, import_child_process.execSync)(
+        `git init; git add --all; git commit --allow-empty -m "chore: first commit"`,
+        {
+          cwd: this.projectPath
+        }
+      );
     }
   }
-  async processTplFile(src, dest, data = {}) {
-    import_handlebars3.default.registerHelper("eq", (a, b) => a === b);
-    const compiledTemplate = import_handlebars3.default.compile(
-      (await fs7.readFile(src)).toString()
-    );
-    const template = await compiledTemplate(data);
-    await fs7.writeFile(dest, template);
+  async catch(error) {
+    if (Error.isError(error)) {
+      console.error(error.message);
+    } else {
+      console.error(error);
+    }
   }
 };