@devbro/pashmak 0.1.9 → 0.1.11

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

@@ -1184,7 +1184,7 @@ var require_lib = __commonJS({
   }
 });
 
-// src/app/console/index.ts
+// src/app/console/index.mts
 var console_exports = {};
 __export(console_exports, {
   CreateProjectCommand: () => CreateProjectCommand,
@@ -1202,6 +1202,9 @@ module.exports = __toCommonJS(console_exports);
 var import_neko_context = require("@devbro/neko-context");
 var import_errors = require("@devbro/neko-http/errors");
 
+// ../neko-router/dist/CompiledRoute.mjs
+var import_stream = require("stream");
+
 // ../neko-router/dist/Middleware.mjs
 var Middleware = class {
   static {
@@ -1279,6 +1282,9 @@ var CompiledRoute = class {
       if (typeof value.toJson === "function") {
         return traverse(value.toJson());
       }
+      if (typeof value.toJSON === "function") {
+        return traverse(value.toJSON());
+      }
       if (Array.isArray(value)) {
         return value.map(traverse);
       }
@@ -1303,7 +1309,7 @@ var CompiledRoute = class {
     }
     return String(obj);
   }
-  processResponseBody(res, controller_rc) {
+  async processResponseBody(res, controller_rc) {
     if (controller_rc && res.writableEnded) {
       throw new Error("cannot write to response, response has already ended");
     }
@@ -1312,18 +1318,36 @@ var CompiledRoute = class {
     }
     if (controller_rc) {
       const header_content_type = res.getHeader("Content-Type");
-      if (!header_content_type && typeof controller_rc === "object") {
+      if (controller_rc instanceof import_stream.Stream || Buffer.isBuffer(controller_rc)) {
+        await this.writeAsync(res, controller_rc);
+        res.end();
+      } else if (!header_content_type && typeof controller_rc === "object") {
         res.setHeader("Content-Type", "application/json");
+        res.end(this.convertToString(controller_rc));
       } else if (!header_content_type) {
         res.setHeader("Content-Type", "text/plain");
+        res.end(this.convertToString(controller_rc));
+      } else {
+        res.end(this.convertToString(controller_rc));
       }
-      res.end(this.convertToString(controller_rc));
       return;
     } else {
       res.statusCode = [200].includes(res.statusCode) ? 204 : res.statusCode;
       res.end();
     }
   }
+  async writeAsync(res, chunk) {
+    return new Promise((resolve, reject) => {
+      const ok = res.write(chunk, (err) => {
+        if (err) reject(err);
+      });
+      if (ok) {
+        resolve(0);
+      } else {
+        res.once("drain", resolve);
+      }
+    });
+  }
   async runMiddlewares(middlewares, req, res) {
     let index = 0;
     const me = this;
@@ -1381,7 +1405,7 @@ var Route = class {
         i = start;
       } else if (char === "*") {
         let start = i + 1;
-        while (start < path8.length && /[a-zA-Z0-9_]/.test(path8[start])) {
+        while (start < path8.length && /[a-zA-Z0-9_\.]/.test(path8[start])) {
           start++;
         }
         tokens.push({ type: "WILDCARD", value: path8.slice(i + 1, start) });
@@ -1451,6 +1475,10 @@ var Route = class {
       params: r.groups || {}
     };
   }
+  prependMiddleware(middlewares) {
+    this.middlewares = [].concat(middlewares, this.middlewares);
+    return this;
+  }
   addMiddleware(middlewares) {
     this.middlewares = this.middlewares.concat(middlewares);
     return this;
@@ -1465,6 +1493,62 @@ var Route = class {
 
 // ../neko-router/dist/Router.mjs
 var import_path = __toESM(require("path"), 1);
+
+// ../node_modules/url-join/lib/url-join.js
+function normalize(strArray) {
+  var resultArray = [];
+  if (strArray.length === 0) {
+    return "";
+  }
+  if (typeof strArray[0] !== "string") {
+    throw new TypeError("Url must be a string. Received " + strArray[0]);
+  }
+  if (strArray[0].match(/^[^/:]+:\/*$/) && strArray.length > 1) {
+    var first = strArray.shift();
+    strArray[0] = first + strArray[0];
+  }
+  if (strArray[0].match(/^file:\/\/\//)) {
+    strArray[0] = strArray[0].replace(/^([^/:]+):\/*/, "$1:///");
+  } else {
+    strArray[0] = strArray[0].replace(/^([^/:]+):\/*/, "$1://");
+  }
+  for (var i = 0; i < strArray.length; i++) {
+    var component = strArray[i];
+    if (typeof component !== "string") {
+      throw new TypeError("Url must be a string. Received " + component);
+    }
+    if (component === "") {
+      continue;
+    }
+    if (i > 0) {
+      component = component.replace(/^[\/]+/, "");
+    }
+    if (i < strArray.length - 1) {
+      component = component.replace(/[\/]+$/, "");
+    } else {
+      component = component.replace(/[\/]+$/, "/");
+    }
+    resultArray.push(component);
+  }
+  var str = resultArray.join("/");
+  str = str.replace(/\/(\?|&|#[^!])/g, "$1");
+  var parts = str.split("?");
+  str = parts.shift() + (parts.length > 0 ? "?" : "") + parts.join("&");
+  return str;
+}
+__name(normalize, "normalize");
+function urlJoin() {
+  var input;
+  if (typeof arguments[0] === "object") {
+    input = arguments[0];
+  } else {
+    input = [].slice.call(arguments);
+  }
+  return normalize(input);
+}
+__name(urlJoin, "urlJoin");
+
+// ../neko-router/dist/Router.mjs
 var Router = class {
   static {
     __name(this, "Router");
@@ -1489,6 +1573,12 @@ var Router = class {
       }).addMiddleware([...controller.baseMiddlewares, ...route.middlewares]);
     }
   }
+  addRouter(path22, router2) {
+    for (const route of router2.routes) {
+      let path222 = urlJoin("/", path22, route.path);
+      this.addRoute(route.methods, path222, route.handler).addMiddleware(router2.getMiddlewares()).addMiddleware(route.getMiddlewares());
+    }
+  }
   addGlobalMiddleware(middlewares) {
     this.middlewares = this.middlewares.concat(middlewares);
   }
@@ -1634,44 +1724,57 @@ var mailer = (0, import_neko_helper.createSingleton)((label) => {
   return rc;
 });
 
-// src/app/console/migrate/MigrateCommand.ts
+// src/app/console/migrate/MigrateCommand.mts
 var import_clipanion2 = require("clipanion");
 var import_neko_context3 = require("@devbro/neko-context");
-var import_path2 = __toESM(require("path"));
-var import_promises = __toESM(require("fs/promises"));
+var import_path2 = __toESM(require("path"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
 var import_neko_config2 = require("@devbro/neko-config");
 var MigrateCommand = class extends import_clipanion2.Command {
   static {
     __name(this, "MigrateCommand");
   }
-  static paths = [
-    [
-      `migrate`
-    ]
-  ];
-  fresh = import_clipanion2.Option.Boolean("--fresh", false);
+  static paths = [[`migrate`]];
+  fresh = import_clipanion2.Option.Boolean(`--fresh`, false, {
+    description: `whether to delete and recreate database`
+  });
+  refresh = import_clipanion2.Option.Boolean(`--refresh`, false, {
+    description: `whether to drop all tables before running migrations by using rollback function`
+  });
   async execute() {
     await import_neko_context3.context_provider.run(async () => {
       const db2 = db();
       const schema = db2.getSchema();
       if (this.fresh) {
-        logger().info("dropping all tables!!");
-        let retry = true;
-        let retry_count = 0;
-        while (retry && retry_count < 10) {
-          retry = false;
-          retry_count++;
-          const tables = await schema.tables();
-          for (const table of tables) {
-            logger().info(`dropping table ${table.name}`);
-            try {
-              await schema.dropTable(table.name);
-            } catch {
-              logger().info(`failed to drop ${table.name}`);
-              retry = true;
-            }
+        throw new Error("not implemented");
+      }
+      if (this.refresh) {
+        logger().info("reverting all migrations!!");
+        const existing_migrations = await db2.runQuery({
+          sql: "select * from migrations order by created_at DESC",
+          bindings: []
+        });
+        const migrationsDir2 = import_neko_config2.config.get("migration.path");
+        for (const migration_record of existing_migrations) {
+          logger().info(`rolling back ${migration_record.filename}`);
+          try {
+            const MigrationClass = (await import(import_path2.default.join(migrationsDir2, migration_record.filename))).default;
+            const migrationInstance = new MigrationClass();
+            await migrationInstance.down(db2.getSchema());
+            await db2.runQuery({
+              sql: "delete from migrations where filename = $1",
+              bindings: [migration_record.filename]
+            });
+          } catch (error) {
+            logger().error(
+              `Failed to rollback migration ${migration_record.filename}: ${error}`
+            );
+            throw error;
           }
         }
+        logger().info(
+          `rolled back ${existing_migrations.length} migrations successfully!`
+        );
       }
       if (!await schema.tableExists("migrations")) {
         await schema.createTable("migrations", (blueprint) => {
@@ -1696,7 +1799,9 @@ var MigrateCommand = class extends import_clipanion2.Command {
         bindings: []
       });
       const completed_migrations = migrations.map((r) => r.filename);
-      const pending_migrations = files.filter((file) => !completed_migrations.includes(file));
+      const pending_migrations = files.filter(
+        (file) => !completed_migrations.includes(file)
+      );
       let migrated_count = 0;
       for (const class_to_migrate of pending_migrations) {
         logger().info(`migrating up ${class_to_migrate}`);
@@ -1705,10 +1810,7 @@ var MigrateCommand = class extends import_clipanion2.Command {
         await c.up(db2.getSchema());
         await db2.runQuery({
           sql: "insert into migrations (filename, batch) values ($1,$2)",
-          bindings: [
-            class_to_migrate,
-            batch_number
-          ]
+          bindings: [class_to_migrate, batch_number]
         });
         migrated_count++;
       }
@@ -1722,13 +1824,13 @@ var MigrateCommand = class extends import_clipanion2.Command {
 };
 cli().register(MigrateCommand);
 
-// src/app/console/migrate/GenerateMigrateCommand.ts
+// src/app/console/migrate/GenerateMigrateCommand.mts
 var import_clipanion3 = require("clipanion");
 var import_change_case_all = require("change-case-all");
-var import_path3 = __toESM(require("path"));
-var fs2 = __toESM(require("fs/promises"));
+var import_path3 = __toESM(require("path"), 1);
+var fs2 = __toESM(require("fs/promises"), 1);
 var import_neko_config3 = require("@devbro/neko-config");
-var import_handlebars = __toESM(require("handlebars"));
+var import_handlebars = __toESM(require("handlebars"), 1);
 var import_url = require("url");
 var import_meta = {};
 var GenerateMigrateCommand = class extends import_clipanion3.Command {
@@ -1736,63 +1838,55 @@ var GenerateMigrateCommand = class extends import_clipanion3.Command {
     __name(this, "GenerateMigrateCommand");
   }
   static paths = [
-    [
-      `generate`,
-      `migrate`
-    ],
-    [
-      "generate",
-      "migration"
-    ]
+    [`generate`, `migrate`],
+    ["generate", "migration"]
   ];
-  name = import_clipanion3.Option.String({
-    required: true
-  });
+  name = import_clipanion3.Option.String({ required: true });
   async execute() {
     const date = /* @__PURE__ */ new Date();
     const year = date.getFullYear();
     const month = String(date.getMonth() + 1).padStart(2, "0");
     const day = String(date.getDate()).padStart(2, "0");
-    const secondsOfDay = String(date.getHours() * 3600 + date.getMinutes() * 60 + date.getSeconds()).padStart(5, "0");
+    const secondsOfDay = String(
+      date.getHours() * 3600 + date.getMinutes() * 60 + date.getSeconds()
+    ).padStart(5, "0");
     const fixed_name = import_change_case_all.Case.snake(this.name);
     const filename = `${year}_${month}_${day}_${secondsOfDay}_${fixed_name}.ts`;
     this.context.stdout.write(`creating migration file ${filename}
 `);
-    await fs2.mkdir(import_neko_config3.config.get("migration.path"), {
-      recursive: true
-    });
+    await fs2.mkdir(import_neko_config3.config.get("migration.path"), { recursive: true });
     let dirname = typeof __dirname === "string" ? __dirname : void 0;
     if (!dirname) {
       dirname = import_path3.default.dirname((0, import_url.fileURLToPath)(import_meta.url));
     }
-    const compiledTemplate = import_handlebars.default.compile((await fs2.readFile(import_path3.default.join(dirname, "./make_migration.tpl"))).toString());
+    const compiledTemplate = import_handlebars.default.compile(
+      (await fs2.readFile(import_path3.default.join(dirname, "./make_migration.tpl"))).toString()
+    );
     const template = await compiledTemplate({
       className: import_change_case_all.Case.pascal(this.name) + "Migration",
       tableName: import_change_case_all.Case.snake(this.name)
     });
-    await fs2.writeFile(import_path3.default.join(import_neko_config3.config.get("migration.path"), filename), template);
+    await fs2.writeFile(
+      import_path3.default.join(import_neko_config3.config.get("migration.path"), filename),
+      template
+    );
   }
 };
 cli().register(GenerateMigrateCommand);
 
-// src/app/console/migrate/MigrateRollbackCommand.ts
+// src/app/console/migrate/MigrateRollbackCommand.mts
 var import_clipanion4 = require("clipanion");
 var import_neko_context4 = require("@devbro/neko-context");
-var import_path4 = __toESM(require("path"));
-var import_promises2 = __toESM(require("fs/promises"));
+var import_path4 = __toESM(require("path"), 1);
+var import_promises2 = __toESM(require("fs/promises"), 1);
 var import_neko_config4 = require("@devbro/neko-config");
-var t = __toESM(require_lib());
+var t = __toESM(require_lib(), 1);
 var MigrateRollbackCommand = class extends import_clipanion4.Command {
   static {
     __name(this, "MigrateRollbackCommand");
   }
-  static paths = [
-    [
-      `migrate`,
-      "rollback"
-    ]
-  ];
-  steps = import_clipanion4.Option.String(`--steps`, {
+  static paths = [[`migrate`, "rollback"]];
+  steps = import_clipanion4.Option.String(`--steps`, "1", {
     description: `how many migrations to rollback`,
     validator: t.isNumber()
   });
@@ -1805,21 +1899,18 @@ var MigrateRollbackCommand = class extends import_clipanion4.Command {
       const dirEntries = await import_promises2.default.readdir(migrationsDir);
       files = dirEntries.filter((entry) => entry.endsWith(".ts")).sort();
       const migrations = await db2.runQuery({
-        sql: "select * from migrations order by created_at DESC",
-        bindings: []
+        sql: "select * from migrations order by created_at DESC limit $1",
+        bindings: [this.steps]
       });
-      const count = 0;
       for (const migration of migrations) {
         const class_to_migrate = migration.filename;
-        this.context.stdout.write(`rolling back ${class_to_migrate}`);
+        logger().info(`rolling back ${class_to_migrate}`);
         const ClassToMigrate = (await import(import_path4.default.join(migrationsDir, class_to_migrate))).default;
         const c = new ClassToMigrate();
         await c.down(db2.getSchema());
         await db2.runQuery({
           sql: "delete from migrations where id = $1",
-          bindings: [
-            migration.id
-          ]
+          bindings: [migration.id]
         });
       }
     });
@@ -1827,7 +1918,7 @@ var MigrateRollbackCommand = class extends import_clipanion4.Command {
 };
 cli().register(MigrateRollbackCommand);
 
-// src/app/console/StartCommand.ts
+// src/app/console/StartCommand.mts
 var import_clipanion5 = require("clipanion");
 var import_neko_config5 = require("@devbro/neko-config");
 var import_neko_sql = require("@devbro/neko-sql");
@@ -1838,19 +1929,13 @@ var StartCommand = class extends import_clipanion5.Command {
   scheduler = import_clipanion5.Option.Boolean(`--scheduler`, false);
   http = import_clipanion5.Option.Boolean(`--http`, false);
   all = import_clipanion5.Option.Boolean("--all", false);
-  static paths = [
-    [
-      `start`
-    ]
-  ];
+  static paths = [[`start`]];
   async execute() {
-    if ([
-      this.all,
-      this.http,
-      this.scheduler
-    ].filter((x) => x).length == 0) {
-      this.context.stdout.write(`No service was selected. please check -h for details
-`);
+    if ([this.all, this.http, this.scheduler].filter((x) => x).length == 0) {
+      this.context.stdout.write(
+        `No service was selected. please check -h for details
+`
+      );
       return;
     }
     logger().info(`Starting Server
@@ -1864,14 +1949,16 @@ var StartCommand = class extends import_clipanion5.Command {
     if (this.http || this.all) {
       const server = httpServer();
       await server.listen(import_neko_config5.config.get("port"), () => {
-        logger().info("Server is running on http://localhost:" + import_neko_config5.config.get("port"));
+        logger().info(
+          "Server is running on http://localhost:" + import_neko_config5.config.get("port")
+        );
       });
     }
   }
 };
 cli().register(StartCommand);
 
-// src/app/console/DefaultCommand.ts
+// src/app/console/DefaultCommand.mts
 var import_clipanion6 = require("clipanion");
 var DefaultCommand = class extends import_clipanion6.Command {
   static {
@@ -1890,7 +1977,9 @@ var DefaultCommand = class extends import_clipanion6.Command {
   async execute() {
     const commandList = cli().registrations;
     const paths = [];
-    commandList.forEach((index, val) => paths.push(index.builder.paths[0]?.join(" ") || ""));
+    commandList.forEach(
+      (index, val) => paths.push(index.builder.paths[0]?.join(" ") || "")
+    );
     console.log("Available commands:");
     for (const cmd of paths) {
       if (cmd) {
@@ -1901,21 +1990,16 @@ var DefaultCommand = class extends import_clipanion6.Command {
 };
 cli().register(DefaultCommand);
 
-// src/app/console/KeyGenerateCommand.ts
+// src/app/console/KeyGenerateCommand.mts
 var import_clipanion7 = require("clipanion");
 var import_crypto = require("crypto");
-var import_promises3 = __toESM(require("fs/promises"));
-var import_path5 = __toESM(require("path"));
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_path5 = __toESM(require("path"), 1);
 var KeyGenerateCommand = class extends import_clipanion7.Command {
   static {
     __name(this, "KeyGenerateCommand");
   }
-  static paths = [
-    [
-      `generate`,
-      "key"
-    ]
-  ];
+  static paths = [[`generate`, "key"]];
   static usage = import_clipanion7.Command.Usage({
     category: `Main`,
     description: `generate keys`,
@@ -1924,14 +2008,8 @@ var KeyGenerateCommand = class extends import_clipanion7.Command {
       Use --rotate flag to preserve old public key.
     `,
     examples: [
-      [
-        `Generate new keys`,
-        `generate key`
-      ],
-      [
-        `Rotate existing keys`,
-        `generate key --rotate`
-      ]
+      [`Generate new keys`, `generate key`],
+      [`Rotate existing keys`, `generate key --rotate`]
     ]
   });
   rotate = import_clipanion7.Option.Boolean(`--rotate`, false, {
@@ -1941,6 +2019,7 @@ var KeyGenerateCommand = class extends import_clipanion7.Command {
     logger().info("generating keys for jwt token and adding to .env file");
     const { publicKey, privateKey } = (0, import_crypto.generateKeyPairSync)("rsa", {
       modulusLength: 2048,
+      // 2048-bit key is standard for RS256
       publicKeyEncoding: {
         type: "spki",
         format: "pem"
@@ -1956,10 +2035,22 @@ var KeyGenerateCommand = class extends import_clipanion7.Command {
     } catch {
     }
     let old_public_key = envfile.match(/^jwt_secret_public=(.*)/m);
-    envfile = this.addEnvParam(envfile, "jwt_secret_public", this.stripPemHeaders(publicKey));
-    envfile = this.addEnvParam(envfile, "jwt_secret_private", this.stripPemHeaders(privateKey));
+    envfile = this.addEnvParam(
+      envfile,
+      "jwt_secret_public",
+      this.stripPemHeaders(publicKey)
+    );
+    envfile = this.addEnvParam(
+      envfile,
+      "jwt_secret_private",
+      this.stripPemHeaders(privateKey)
+    );
     if (this.rotate && old_public_key && old_public_key[1]) {
-      envfile = this.addEnvParam(envfile, "jwt_secret_public_retired", old_public_key[1]);
+      envfile = this.addEnvParam(
+        envfile,
+        "jwt_secret_public_retired",
+        old_public_key[1]
+      );
     }
     await import_promises3.default.writeFile(import_path5.default.join(process.cwd(), ".env"), envfile, "utf-8");
   }
@@ -1979,81 +2070,73 @@ ${key}=${value}`;
 };
 cli().register(KeyGenerateCommand);
 
-// src/app/console/generate/GenerateControllerCommand.ts
+// src/app/console/generate/GenerateControllerCommand.mts
 var import_clipanion8 = require("clipanion");
 var import_change_case_all2 = require("change-case-all");
-var import_path6 = __toESM(require("path"));
-var fs5 = __toESM(require("fs/promises"));
+var import_path6 = __toESM(require("path"), 1);
+var fs5 = __toESM(require("fs/promises"), 1);
 var import_neko_config6 = require("@devbro/neko-config");
-var import_handlebars2 = __toESM(require("handlebars"));
+var import_handlebars2 = __toESM(require("handlebars"), 1);
 var import_url2 = require("url");
-var import_pluralize = __toESM(require("pluralize"));
+var import_pluralize = __toESM(require("pluralize"), 1);
 var import_meta2 = {};
 var GenerateControllerCommand = class extends import_clipanion8.Command {
   static {
     __name(this, "GenerateControllerCommand");
   }
   static paths = [
-    [
-      `make`,
-      `controller`
-    ],
-    [
-      `generate`,
-      `controller`
-    ]
+    [`make`, `controller`],
+    [`generate`, `controller`]
   ];
-  name = import_clipanion8.Option.String({
-    required: true
-  });
+  name = import_clipanion8.Option.String({ required: true });
   async execute() {
     const rootDir = process.cwd();
     const date = /* @__PURE__ */ new Date();
     const year = date.getFullYear();
     const month = String(date.getMonth() + 1).padStart(2, "0");
     const day = String(date.getDate()).padStart(2, "0");
-    const secondsOfDay = String(date.getHours() * 3600 + date.getMinutes() * 60 + date.getSeconds()).padStart(5, "0");
+    const secondsOfDay = String(
+      date.getHours() * 3600 + date.getMinutes() * 60 + date.getSeconds()
+    ).padStart(5, "0");
     const fixed_name = import_change_case_all2.Case.snake(this.name);
     const filename = `${import_change_case_all2.Case.capital(this.name)}Controller.ts`;
     this.context.stdout.write(`creating migration file ${filename}
 `);
-    await fs5.mkdir(import_neko_config6.config.get("migration.path"), {
-      recursive: true
-    });
+    await fs5.mkdir(import_neko_config6.config.get("migration.path"), { recursive: true });
     let dirname = typeof __dirname === "string" ? __dirname : void 0;
     if (!dirname) {
       dirname = import_path6.default.dirname((0, import_url2.fileURLToPath)(import_meta2.url));
     }
-    const compiledTemplate = import_handlebars2.default.compile((await fs5.readFile(import_path6.default.join(dirname, "./controller.tpl"))).toString());
+    const compiledTemplate = import_handlebars2.default.compile(
+      (await fs5.readFile(import_path6.default.join(dirname, "./controller.tpl"))).toString()
+    );
     const template = await compiledTemplate({
       className: import_change_case_all2.Case.pascal(this.name),
       classNameLower: import_change_case_all2.Case.snake(this.name),
       routeName: import_change_case_all2.Case.kebab((0, import_pluralize.default)(this.name))
     });
-    await fs5.writeFile(import_path6.default.join(rootDir, "src/app/controllers", filename), template);
+    await fs5.writeFile(
+      import_path6.default.join(rootDir, "src/app/controllers", filename),
+      template
+    );
   }
 };
 cli().register(GenerateControllerCommand);
 
-// src/app/console/project/CreateProjectCommand.ts
+// src/app/console/project/CreateProjectCommand.mts
 var import_clipanion9 = require("clipanion");
 var import_change_case_all3 = require("change-case-all");
-var import_path7 = __toESM(require("path"));
-var fs6 = __toESM(require("fs/promises"));
+var import_path7 = __toESM(require("path"), 1);
+var fs6 = __toESM(require("fs/promises"), 1);
 var import_url3 = require("url");
-var import_handlebars3 = __toESM(require("handlebars"));
+var import_handlebars3 = __toESM(require("handlebars"), 1);
 var import_child_process = require("child_process");
 var import_meta3 = {};
 var CreateProjectCommand = class extends import_clipanion9.Command {
   static {
     __name(this, "CreateProjectCommand");
   }
-  static paths = [
-    [
-      `create`,
-      `project`
-    ]
-  ];
+  static paths = [[`create`, `project`]];
   static usage = import_clipanion9.Command.Usage({
     category: `Project`,
     description: `Create a new project`,
@@ -2072,9 +2155,7 @@ var CreateProjectCommand = class extends import_clipanion9.Command {
       ]
     ]
   });
-  projectPath = import_clipanion9.Option.String("--path", {
-    required: true
-  });
+  projectPath = import_clipanion9.Option.String("--path", { required: true });
   git = import_clipanion9.Option.Boolean(`--git`, false, {
     description: `Initialize a git repository in the new project`
   });
@@ -2097,9 +2178,7 @@ var CreateProjectCommand = class extends import_clipanion9.Command {
       return 1;
     } catch {
     }
-    await fs6.mkdir(projectPath, {
-      recursive: true
-    });
+    await fs6.mkdir(projectPath, { recursive: true });
     console.log(`Created project directory at: ${projectPath}`);
     const dirname = typeof __dirname === "undefined" ? import_path7.default.dirname((0, import_url3.fileURLToPath)(import_meta3.url)) : __dirname;
     let basePath = import_path7.default.join(dirname, `./base_project`);
@@ -2117,9 +2196,12 @@ var CreateProjectCommand = class extends import_clipanion9.Command {
     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
-        });
+        (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;
@@ -2127,32 +2209,32 @@ var CreateProjectCommand = class extends import_clipanion9.Command {
     }
   }
   async processTplFolder(src, dest, data = {}) {
-    const files = await fs6.readdir(src, {
-      withFileTypes: true
-    });
+    const files = await fs6.readdir(src, { withFileTypes: true });
     for (const file of files) {
       const srcPath = import_path7.default.join(src, file.name);
       const destPath = file.isFile() && file.name.endsWith(".tpl") ? import_path7.default.join(dest, file.name.substring(0, file.name.length - 4)) : import_path7.default.join(dest, file.name);
       if (file.isDirectory()) {
-        await fs6.mkdir(destPath, {
-          recursive: true
-        });
+        await fs6.mkdir(destPath, { recursive: true });
         await this.processTplFolder(srcPath, destPath, data);
       } else if (file.name.endsWith(".tpl")) {
         await this.processTplFile(srcPath, destPath, {});
       } else {
-        throw new Error("unexpected non tpl file: " + srcPath + " " + file.name);
+        throw new Error(
+          "unexpected non tpl file: " + srcPath + " " + file.name
+        );
       }
     }
   }
   async processTplFile(src, dest, data = {}) {
-    const compiledTemplate = import_handlebars3.default.compile((await fs6.readFile(src)).toString());
+    const compiledTemplate = import_handlebars3.default.compile(
+      (await fs6.readFile(src)).toString()
+    );
     const template = await compiledTemplate(data);
     await fs6.writeFile(dest, template);
   }
 };
 
-// src/app/console/index.ts
+// src/app/console/index.mts
 cli().register(CreateProjectCommand);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {