mahameru 0.0.0

package/dist/cli/index.cjs

@@ -0,0 +1,706 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = /* @__PURE__ */ __name(() => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href, "getImportMetaUrl");
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/cli/index.ts
+var import_commander = require("commander");
+
+// package.json
+var package_exports = {};
+__export(package_exports, {
+  author: () => author,
+  bin: () => bin,
+  default: () => package_default,
+  dependencies: () => dependencies,
+  description: () => description,
+  devDependencies: () => devDependencies,
+  exports: () => exports2,
+  files: () => files,
+  keywords: () => keywords,
+  license: () => license,
+  main: () => main,
+  module: () => module2,
+  name: () => name,
+  peerDependencies: () => peerDependencies,
+  scripts: () => scripts,
+  type: () => type,
+  types: () => types,
+  version: () => version
+});
+var name = "mahameru";
+var version = "0.1.0";
+var description = "";
+var main = "./dist/index.cjs";
+var module2 = "./dist/index.js";
+var types = "./dist/index.d.ts";
+var bin = "./dist/cli/index.js";
+var scripts = {
+  dev: "set NODE_ENV=development && tsx watch --tsconfig tsconfig.json --conditions=development src/index.ts",
+  build: "tsup --config tsup.config.ts && npm pack",
+  start: "node dist/index.js",
+  typecheck: "tsc --noEmit --project tsconfig.json"
+};
+var exports2 = {
+  ".": {
+    types: "./dist/index.d.ts",
+    import: "./dist/index.js",
+    require: "./dist/index.cjs"
+  },
+  "./database": {
+    types: "./dist/database/index.d.ts",
+    import: "./dist/database/index.js",
+    require: "./dist/database/index.cjs"
+  },
+  "./database/column": {
+    types: "./dist/database/column/index.d.ts",
+    import: "./dist/database/column/index.js",
+    require: "./dist/database/column/index.cjs"
+  }
+};
+var files = [
+  "dist"
+];
+var keywords = [];
+var author = "Bintan <hello@bintvn.co>";
+var license = "ISC";
+var type = "module";
+var peerDependencies = {
+  "@types/node": "^26.0.0",
+  "tsc-alias": "^1.8.17",
+  tsx: "^4.22.4",
+  typeorm: "^1.0.0",
+  typescript: "^6.0.3"
+};
+var dependencies = {
+  commander: "^15.0.0",
+  "cookie-parser": "^1.4.7",
+  cors: "^2.8.6",
+  degit: "^3.4.7",
+  express: "^5.2.1",
+  helmet: "^8.2.0",
+  inquirer: "^14.0.2",
+  "lite-env": "^1.1.0",
+  ora: "^9.4.0",
+  picocolors: "^1.1.1",
+  "typeorm-dto-generator": "^1.0.6"
+};
+var devDependencies = {
+  "@swc/core": "^1.15.41",
+  "@types/cookie-parser": "^1.4.10",
+  "@types/cors": "^2.8.19",
+  "@types/express": "^5.0.6",
+  "@types/helmet": "^0.0.48",
+  "@types/node": "^26.0.0",
+  "tsc-alias": "^1.8.17",
+  tsup: "^8.5.1",
+  tsx: "^4.22.4",
+  typeorm: "^1.0.0",
+  typescript: "^6.0.3"
+};
+var package_default = {
+  name,
+  version,
+  description,
+  main,
+  module: module2,
+  types,
+  bin,
+  scripts,
+  exports: exports2,
+  files,
+  keywords,
+  author,
+  license,
+  type,
+  peerDependencies,
+  dependencies,
+  devDependencies
+};
+
+// src/cli/scripts/on-init.ts
+var import_inquirer = __toESM(require("inquirer"), 1);
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"), 1);
+var import_degit = __toESM(require("degit"), 1);
+var import_ora = __toESM(require("ora"), 1);
+var import_picocolors = __toESM(require("picocolors"), 1);
+var import_node_child_process = require("child_process");
+async function onInit() {
+  const repo = "bintvn/typeorm-dto-generator";
+  const answers = await import_inquirer.default.prompt([
+    {
+      type: "input",
+      name: "projectName",
+      message: "Enter your project name:",
+      default: "my-awesome-project",
+      validate: /* @__PURE__ */ __name((input) => {
+        if (/^([A-Za-z\-_\d])+$/.test(input)) return true;
+        return "Project name may only contain letters, numbers, underscores, or dashes.";
+      }, "validate")
+    }
+  ]);
+  const targetDir = import_node_path.default.join(process.cwd(), answers.projectName);
+  if ((0, import_node_fs.existsSync)(targetDir)) {
+    console.log(import_picocolors.default.red(`
+Error: Folder ${answers.projectName} already exists!`));
+    process.exit(1);
+  }
+  const emitter = (0, import_degit.default)(repo, {
+    cache: false,
+    force: true
+  });
+  const downloadSpinner = (0, import_ora.default)("Downloading template from GitHub...").start();
+  try {
+    await emitter.clone(targetDir);
+    downloadSpinner.succeed(import_picocolors.default.green("Template downloaded successfully!"));
+  } catch (err) {
+    downloadSpinner.fail(import_picocolors.default.red("Failed to download template."));
+    console.error(err);
+    process.exit(1);
+  }
+  const installSpinner = (0, import_ora.default)("Installing dependencies (npm install)...").start();
+  try {
+    (0, import_node_child_process.execSync)("npm install", {
+      cwd: targetDir,
+      stdio: "ignore"
+    });
+    installSpinner.succeed(import_picocolors.default.green("Dependencies installed successfully!"));
+  } catch (err) {
+    installSpinner.fail(import_picocolors.default.red("Failed to install dependencies."));
+    console.log(import_picocolors.default.yellow('\nPlease enter the folder and run "npm install" manually.'));
+  }
+  console.log("\n---");
+  console.log(import_picocolors.default.cyan(`Project ${import_picocolors.default.bold(answers.projectName)} was created successfully!`));
+  console.log(`
+To get started, run the following commands:`);
+  console.log(import_picocolors.default.yellow(`   cd ${answers.projectName}`));
+  console.log(import_picocolors.default.yellow(`   npm run dev (or your preferred start command)`));
+  console.log("---\n");
+}
+__name(onInit, "onInit");
+
+// src/cli/scripts/on-build.ts
+var import_node_child_process2 = require("child_process");
+var import_node_fs2 = require("fs");
+var import_node_path2 = __toESM(require("path"), 1);
+async function onBuild() {
+  console.log("\x1B[32m%s\x1B[0m", "\u25B2 Mahameru - Compiling TypeScript with tsc...");
+  try {
+    const tscPath = import_node_path2.default.join(process.cwd(), "node_modules", "typescript", "bin", "tsc");
+    const tscAliasPath = import_node_path2.default.join(process.cwd(), "node_modules", "tsc-alias", "dist", "bin", "index.js");
+    (0, import_node_child_process2.execSync)(`node "${tscPath}" -p tsconfig.json && node "${tscAliasPath}" -p tsconfig.json`, {
+      stdio: "inherit",
+      cwd: process.cwd()
+    });
+    (0, import_node_fs2.renameSync)(import_node_path2.default.join(process.cwd(), "dist"), import_node_path2.default.join(process.cwd(), ".mahameru"));
+    console.log("\x1B[32m%s\x1B[0m", "\u2714 Build berhasil selesai.");
+  } catch (error) {
+    console.error("\x1B[31m%s\x1B[0m", "\u2716 Build gagal.");
+    process.exit(1);
+  }
+}
+__name(onBuild, "onBuild");
+
+// src/cli/scripts/on-start.ts
+var import_node_child_process3 = require("child_process");
+var import_node_path3 = __toESM(require("path"), 1);
+async function onStart() {
+  console.log("\x1B[36m%s\x1B[0m", "\u25B2 Mahameru - Starting production server...");
+  const distPath = import_node_path3.default.join(process.cwd(), ".mahameru", "index.js");
+  const child = (0, import_node_child_process3.spawn)("node", [
+    distPath
+  ], {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      NODE_ENV: "production"
+    }
+  });
+  child.on("close", (code) => {
+    process.exit(code ?? 0);
+  });
+}
+__name(onStart, "onStart");
+
+// src/cli/scripts/on-dev.ts
+var import_node_url2 = require("url");
+
+// src/error.ts
+var MahameruError = class extends Error {
+  static {
+    __name(this, "MahameruError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "MahameruError";
+    this.message = message;
+    Error.captureStackTrace(this, this.constructor);
+  }
+  toString() {
+    return `${this.name}: ${this.message}`;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message
+    };
+  }
+};
+
+// src/http.ts
+var import_node_http = require("http");
+function createHttpServer(app, existingHttpServer, options = {}) {
+  return new Promise((resolve, reject) => {
+    const httpServer = (0, import_node_http.createServer)(app);
+    const PORT = options.port || 3e3;
+    const HOST = options.host || "localhost";
+    if (existingHttpServer) return resolve(existingHttpServer);
+    httpServer.listen(PORT, HOST, void 0, async () => {
+      const address = httpServer.address();
+      if (address && typeof address !== "string") {
+        console.log("HTTP Server", `Listening on http://${HOST} ${PORT} ${address.family}`);
+      } else {
+        console.log("HTTP Server", `Listening on ${address}`);
+      }
+      resolve(httpServer);
+    });
+    httpServer.on("close", () => {
+      console.log("HTTP Server", "Server closed");
+      process.exit(0);
+    });
+    httpServer.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        reject(new MahameruError(`Port ${PORT} is already in use`));
+        return;
+      } else {
+        console.error("System", err);
+      }
+      reject(err);
+    });
+  });
+}
+__name(createHttpServer, "createHttpServer");
+
+// src/mahameru.ts
+var import_promises = require("fs/promises");
+var import_path = __toESM(require("path"), 1);
+var import_fs = require("fs");
+var import_child_process = require("child_process");
+
+// src/constants.ts
+var import_node_path4 = require("path");
+var import_node_url = require("url");
+var root = process.cwd();
+var __filename2 = (0, import_node_url.fileURLToPath)(importMetaUrl);
+var __dirname = (0, import_node_path4.dirname)(__filename2);
+var isCommonJS = typeof module !== "undefined" && !!module.exports;
+
+// src/express/app.ts
+var import_express = __toESM(require("express"), 1);
+var import_helmet = __toESM(require("helmet"), 1);
+
+// src/express/middleware/cors.middleware.ts
+var import_cors = __toESM(require("cors"), 1);
+var createCorsMiddleware = /* @__PURE__ */ __name((allowedOrigins) => {
+  return (0, import_cors.default)((req, callback) => {
+    let origin = req.headers["origin"];
+    if (!origin || allowedOrigins.indexOf(origin) !== -1) {
+      callback(null, {
+        origin: true,
+        methods: "GET,HEAD,PUT,PATCH,POST,DELETE",
+        credentials: true
+      });
+    } else {
+      callback(null, {
+        origin: false
+      });
+    }
+  });
+}, "createCorsMiddleware");
+var cors_middleware_default = createCorsMiddleware;
+
+// src/express/middleware/filter.middleware.ts
+async function filterMiddleware(request, response, next) {
+  if (!request.ip || !request.headers["user-agent"]) throw new Error("Access denied");
+  request.ipAddress = request.ip;
+  request.userAgent = request.headers["user-agent"];
+  if (request.path.length > 1 && request.path.endsWith("/")) {
+    const newPath = request.path.slice(0, -1);
+    const query = request.url.slice(request.path.length);
+    return response.redirect(301, newPath + query);
+  }
+  return next();
+}
+__name(filterMiddleware, "filterMiddleware");
+
+// src/api.error.ts
+var API_ERROR_STATUS = {
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  ROUTE_NOT_FOUND: 404,
+  TOO_MANY_REQUESTS: 429,
+  CONFLICT: 409,
+  INTERNAL_SERVER_ERROR: 500,
+  TOKEN_EXPIRED: 401,
+  REFRESH_TOKEN_EXPIRED: 401,
+  ACCESS_TOKEN_EXPIRED: 401,
+  ACCESS_TOKEN_REQUIRED: 401,
+  TOKEN_REFRESH_TOO_EARLY: 403,
+  EMAIL_NOT_VERIFIED: 401,
+  PHONE_NOT_VERIFIED: 401,
+  TOKEN_NOT_FOUND: 404,
+  INVALID_TOKEN: 401,
+  RESET_PASSWORD_TOKEN_USED: 401,
+  RESET_PASSWORD_NEEDED: 400,
+  ROLE_DISABLED: 403,
+  SESSION_NOT_FOUND: 404,
+  SESSION_DISABLED: 401,
+  INVALID_RESPONSE: 500,
+  UNKNOWN_CLIENT_ERROR: 400,
+  INVALID_CREDENTIALS: 400,
+  VALIDATION_ERROR: 400
+};
+var APIError = class _APIError extends Error {
+  static {
+    __name(this, "APIError");
+  }
+  code;
+  status;
+  details;
+  constructor(...args) {
+    const [code, message, details] = args;
+    super(message);
+    this.name = "APIError";
+    this.code = code;
+    this.status = API_ERROR_STATUS[code];
+    this.details = details;
+    Object.setPrototypeOf(this, _APIError.prototype);
+  }
+};
+
+// src/express/middleware/not-found.middleware.ts
+async function notFoundMiddleware(request) {
+  throw new APIError("ROUTE_NOT_FOUND", `Route ${request.path} is not found!`);
+}
+__name(notFoundMiddleware, "notFoundMiddleware");
+
+// src/express/middleware/error.middleware.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype;
+}
+__name(isPlainObject, "isPlainObject");
+var createErrorMiddleware = /* @__PURE__ */ __name((cookieTokenOptions) => (error, req, res, _) => {
+  try {
+    res.setHeader("Cache-Control", "no-store");
+    if (error instanceof APIError) {
+      if (error.code === "INTERNAL_SERVER_ERROR") {
+        console.error(error);
+        return res.status(error.status).json({
+          success: false,
+          error: error.code,
+          message: "An internal error is happening. Please contact developer as soon as possible!"
+        });
+      }
+      if (error.code === "TOKEN_NOT_FOUND") {
+        if (req.cookies.token) res.clearCookie("token", cookieTokenOptions);
+      }
+      if (isPlainObject(error.details) && "retryIn" in error.details && typeof error.details.retryIn === "number") res.setHeader("Retry-After", error.details.retryIn);
+      const responseBody = {
+        success: false,
+        error: error.code,
+        ...error.message ? {
+          message: error.message
+        } : {},
+        ...isPlainObject(error.details) ? error.details : {}
+      };
+      return res.status(error.status).json(responseBody);
+    }
+    if (error instanceof SyntaxError) {
+      return res.status(error.statusCode).json({
+        success: false,
+        error: "JSON_PARSE_ERROR",
+        message: error.message
+      });
+    }
+    if (error instanceof Error) {
+      console.error(error);
+      return res.status(500).json({
+        success: false,
+        error: "UNKNOWN_ERROR",
+        message: "An unknown error is happening. Please contact developer as soon as possible!"
+      });
+    }
+    console.error("errorHandlerMiddleware", error);
+    return res.status(500).json({
+      success: false,
+      error: "INTERNAL_SERVER_ERROR",
+      message: "An internal error is happening. Please contact developer as soon as possible!"
+    });
+  } catch (error2) {
+    console.error("errorHandlerMiddleware", error2);
+    return res.status(500).json({
+      success: false,
+      error: "INTERNAL_SERVER_ERROR",
+      message: "An internal error is happening. Please contact developer as soon as possible!"
+    });
+  }
+}, "createErrorMiddleware");
+var error_middleware_default = createErrorMiddleware;
+
+// src/express/app.ts
+var import_cookie_parser = __toESM(require("cookie-parser"), 1);
+var createExpressApp = /* @__PURE__ */ __name((options) => {
+  const app = (0, import_express.default)();
+  app.set("trust proxy", 1);
+  app.disable("x-powered-by");
+  app.use((0, import_helmet.default)());
+  app.use(cors_middleware_default(options.allowedOrigins));
+  app.use(filterMiddleware);
+  app.use(import_express.default.json({
+    limit: "1mb"
+  }));
+  app.use((0, import_cookie_parser.default)(options.cookieSecret));
+  app.use(import_express.default.urlencoded({
+    extended: true,
+    limit: "1mb"
+  }));
+  app.use(import_express.default.static("public", {
+    dotfiles: "deny",
+    etag: true,
+    immutable: false,
+    index: false,
+    lastModified: true,
+    maxAge: "1h"
+  }));
+  app.get("/", (request, response) => {
+    return response.status(200).json({
+      success: true,
+      message: `Welcome to ${options.appName}`,
+      data: {
+        userAgent: request.userAgent,
+        ipAddress: request.ipAddress
+      }
+    });
+  });
+  if (options.routes) {
+    app.use(options.routes.public);
+    app.use(options.routes.private);
+  }
+  app.use(notFoundMiddleware);
+  app.use(error_middleware_default(options.cookieOptions));
+  return app;
+}, "createExpressApp");
+var app_default = createExpressApp;
+
+// src/mahameru.ts
+var Mahameru = class {
+  static {
+    __name(this, "Mahameru");
+  }
+  config;
+  rootDir = process.cwd();
+  databasesDir = import_path.default.join(this.rootDir, "src", "databases");
+  isCommonJS = typeof module !== "undefined" && !!module.exports;
+  isBuild = __dirname.includes("dist");
+  shouldInitDB = true;
+  constructor(config) {
+    this.config = config;
+    if (!this.config) throw new MahameruError("Mahameru config is not provided");
+    if (!this.config.options) throw new MahameruError("Mahameru config.options is not provided");
+    if (!(0, import_fs.existsSync)(this.rootDir)) throw new MahameruError("Root directory does not exist");
+    if (!(0, import_fs.existsSync)(import_path.default.join(this.rootDir, "src"))) throw new MahameruError("src directory does not exist");
+    if (typeof this.config.options.dev === "undefined") this.config.options.dev = false;
+    if (!(0, import_fs.existsSync)(this.databasesDir)) this.shouldInitDB = false;
+  }
+  async initialize() {
+    console.log("Preparing mahameru...");
+    if (this.config.options.dev) await this.preInitDevelopment(this.shouldInitDB);
+    console.log(`Starting mahameru on port ${this.config.options.port} in ${this.config.options.dev ? "development" : "production"} mode...`);
+    const app = app_default({
+      allowedOrigins: this.config.httpAllowedOrigins || [],
+      cookieSecret: this.config.cookieSecret || "secret",
+      cookieOptions: this.config.cookieOptions || {},
+      appName: this.config.options.appName || "Mahameru"
+    });
+    const httpServer = await createHttpServer(app, this.config.httpServer, {
+      port: this.config.options.port,
+      host: this.config.options.host
+    });
+    console.log("Mahameru is ready!");
+    const shutdown = /* @__PURE__ */ __name(async (signal) => {
+      if (signal) console.log("shutdown", `Received signal ${signal}`);
+      httpServer.close();
+      console.log("shutdown", `Shutdown complete.`);
+    }, "shutdown");
+    process.on("SIGINT", this.config.onSigint || shutdown);
+    process.on("SIGTERM", this.config.onSigterm || shutdown);
+  }
+  async preInitDevelopment(shouldInitDB = false) {
+    await this.createRequiredEnvFile();
+    const tsxPath = import_path.default.join(process.cwd(), "node_modules", "tsx", "dist", this.isCommonJS ? "cli.cjs" : "cli.mjs");
+    const preInitScriptPath = `node_modules${import_path.default.sep}mahameru${import_path.default.sep}${this.isBuild ? "dist" : "src"}${import_path.default.sep}lib${import_path.default.sep}pre-init-dev-script.${this.isCommonJS ? "cjs" : "js"}`;
+    const args = [
+      tsxPath,
+      "--tsconfig",
+      "tsconfig.json",
+      preInitScriptPath,
+      shouldInitDB ? "--init-db" : null
+    ].filter(Boolean);
+    return await new Promise((resolve, reject) => {
+      const child = (0, import_child_process.spawn)("node", args, {
+        stdio: "inherit",
+        env: {
+          ...process.env,
+          NODE_ENV: "development"
+        }
+      });
+      child.on("close", (code) => {
+        resolve(code);
+      });
+      child.on("error", (err) => {
+        reject(err);
+      });
+    });
+  }
+  async createRequiredEnvFile() {
+    const envDefaultPath = import_path.default.join(this.rootDir, ".env");
+    const envDevelopmentPath = import_path.default.join(this.rootDir, ".env.development");
+    if (!(0, import_fs.existsSync)(envDefaultPath)) await (0, import_promises.writeFile)(envDefaultPath, "APP_NAME=Mahameru Node.js Framework", "utf-8");
+    if (!(0, import_fs.existsSync)(envDevelopmentPath)) {
+      const devEnv = ``;
+      await (0, import_promises.writeFile)(envDevelopmentPath, devEnv, "utf-8");
+    }
+  }
+  isClass(v) {
+    return typeof v === "function" && /^\s*class\s+/.test(v.toString());
+  }
+};
+
+// src/client.ts
+var mahameru = /* @__PURE__ */ __name((config) => {
+  try {
+    const mahameru2 = new Mahameru(config);
+    return mahameru2;
+  } catch (err) {
+    console.error(err);
+    process.exit(1);
+  }
+}, "mahameru");
+var client_default = mahameru;
+
+// src/base-class/base.entity.ts
+var import_typeorm = require("typeorm");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var BaseEntity = class {
+  static {
+    __name(this, "BaseEntity");
+  }
+  id;
+  createdAt;
+  updatedAt;
+  isDisabled;
+};
+_ts_decorate([
+  (0, import_typeorm.PrimaryGeneratedColumn)("uuid"),
+  _ts_metadata("design:type", String)
+], BaseEntity.prototype, "id", void 0);
+_ts_decorate([
+  (0, import_typeorm.CreateDateColumn)({
+    type: "datetime",
+    precision: 3,
+    default: /* @__PURE__ */ __name(() => "UTC_TIMESTAMP(3)", "default")
+  }),
+  _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], BaseEntity.prototype, "createdAt", void 0);
+_ts_decorate([
+  (0, import_typeorm.Column)({
+    type: "datetime",
+    precision: 3,
+    default: null,
+    nullable: true
+  }),
+  _ts_metadata("design:type", Object)
+], BaseEntity.prototype, "updatedAt", void 0);
+_ts_decorate([
+  (0, import_typeorm.Column)({
+    type: "boolean",
+    default: false
+  }),
+  _ts_metadata("design:type", Boolean)
+], BaseEntity.prototype, "isDisabled", void 0);
+
+// src/base-class/base.model.ts
+var import_typeorm2 = require("typeorm");
+
+// src/index.ts
+var index_default = client_default;
+
+// src/cli/scripts/on-dev.ts
+var import_node_path5 = __toESM(require("path"), 1);
+async function onDev(cliOptions) {
+  try {
+    console.log("\x1B[36m%s\x1B[0m", "\u25B2 Mahameru - Starting development server...");
+    const root2 = process.cwd();
+    const configPath = (0, import_node_url2.pathToFileURL)(import_node_path5.default.join(root2, "mahameru.config.ts")).href;
+    const module3 = await import(configPath);
+    if (!module3.default) throw new MahameruError("Mahameru config not found");
+    const mahameruConfig = module3.default;
+    const app = index_default(mahameruConfig);
+    await app.initialize();
+  } catch (error) {
+    console.error(error);
+  }
+}
+__name(onDev, "onDev");
+
+// src/cli/index.ts
+var { default: { version: version2 } } = package_exports;
+var program = new import_commander.Command();
+program.name("mahameru").version(version2).description("Mahameru - A minimal and fast Node.js framework for building HTTP servers");
+program.command("init").description("Initialize a new project from a GitHub template").action(onInit);
+program.command("dev").description("Start the development server").option("-p, --port <port>", "Port to run the development server on", "3000").action(onDev);
+program.command("build").description("Build project").action(onBuild);
+program.command("start").description("Start the production server").action(onStart);
+program.parse(process.argv);
+//# sourceMappingURL=index.cjs.map