mahameru 0.0.0

package/dist/cli/index.js

@@ -0,0 +1,681 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+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 });
+};
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// package.json
+var package_exports = {};
+__export(package_exports, {
+  author: () => author,
+  bin: () => bin,
+  default: () => package_default,
+  dependencies: () => dependencies,
+  description: () => description,
+  devDependencies: () => devDependencies,
+  exports: () => exports,
+  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 exports = {
+  ".": {
+    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,
+  files,
+  keywords,
+  author,
+  license,
+  type,
+  peerDependencies,
+  dependencies,
+  devDependencies
+};
+
+// src/cli/scripts/on-init.ts
+import inquirer from "inquirer";
+import { existsSync } from "fs";
+import path from "path";
+import degit from "degit";
+import ora from "ora";
+import pc from "picocolors";
+import { execSync } from "child_process";
+async function onInit() {
+  const repo = "bintvn/typeorm-dto-generator";
+  const answers = await inquirer.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 = path.join(process.cwd(), answers.projectName);
+  if (existsSync(targetDir)) {
+    console.log(pc.red(`
+Error: Folder ${answers.projectName} already exists!`));
+    process.exit(1);
+  }
+  const emitter = degit(repo, {
+    cache: false,
+    force: true
+  });
+  const downloadSpinner = ora("Downloading template from GitHub...").start();
+  try {
+    await emitter.clone(targetDir);
+    downloadSpinner.succeed(pc.green("Template downloaded successfully!"));
+  } catch (err) {
+    downloadSpinner.fail(pc.red("Failed to download template."));
+    console.error(err);
+    process.exit(1);
+  }
+  const installSpinner = ora("Installing dependencies (npm install)...").start();
+  try {
+    execSync("npm install", {
+      cwd: targetDir,
+      stdio: "ignore"
+    });
+    installSpinner.succeed(pc.green("Dependencies installed successfully!"));
+  } catch (err) {
+    installSpinner.fail(pc.red("Failed to install dependencies."));
+    console.log(pc.yellow('\nPlease enter the folder and run "npm install" manually.'));
+  }
+  console.log("\n---");
+  console.log(pc.cyan(`Project ${pc.bold(answers.projectName)} was created successfully!`));
+  console.log(`
+To get started, run the following commands:`);
+  console.log(pc.yellow(`   cd ${answers.projectName}`));
+  console.log(pc.yellow(`   npm run dev (or your preferred start command)`));
+  console.log("---\n");
+}
+__name(onInit, "onInit");
+
+// src/cli/scripts/on-build.ts
+import { execSync as execSync2 } from "child_process";
+import { renameSync } from "fs";
+import path2 from "path";
+async function onBuild() {
+  console.log("\x1B[32m%s\x1B[0m", "\u25B2 Mahameru - Compiling TypeScript with tsc...");
+  try {
+    const tscPath = path2.join(process.cwd(), "node_modules", "typescript", "bin", "tsc");
+    const tscAliasPath = path2.join(process.cwd(), "node_modules", "tsc-alias", "dist", "bin", "index.js");
+    execSync2(`node "${tscPath}" -p tsconfig.json && node "${tscAliasPath}" -p tsconfig.json`, {
+      stdio: "inherit",
+      cwd: process.cwd()
+    });
+    renameSync(path2.join(process.cwd(), "dist"), path2.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
+import { spawn } from "child_process";
+import path3 from "path";
+async function onStart() {
+  console.log("\x1B[36m%s\x1B[0m", "\u25B2 Mahameru - Starting production server...");
+  const distPath = path3.join(process.cwd(), ".mahameru", "index.js");
+  const child = 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
+import { pathToFileURL } from "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
+import { createServer } from "http";
+function createHttpServer(app, existingHttpServer, options = {}) {
+  return new Promise((resolve, reject) => {
+    const httpServer = 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
+import { writeFile } from "fs/promises";
+import path4 from "path";
+import { existsSync as existsSync2 } from "fs";
+import { spawn as spawn2 } from "child_process";
+
+// src/constants.ts
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+var root = process.cwd();
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+var isCommonJS = typeof module !== "undefined" && !!module.exports;
+
+// src/express/app.ts
+import express from "express";
+import helmet from "helmet";
+
+// src/express/middleware/cors.middleware.ts
+import cors from "cors";
+var createCorsMiddleware = /* @__PURE__ */ __name((allowedOrigins) => {
+  return cors((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
+import cookieParser from "cookie-parser";
+var createExpressApp = /* @__PURE__ */ __name((options) => {
+  const app = express();
+  app.set("trust proxy", 1);
+  app.disable("x-powered-by");
+  app.use(helmet());
+  app.use(cors_middleware_default(options.allowedOrigins));
+  app.use(filterMiddleware);
+  app.use(express.json({
+    limit: "1mb"
+  }));
+  app.use(cookieParser(options.cookieSecret));
+  app.use(express.urlencoded({
+    extended: true,
+    limit: "1mb"
+  }));
+  app.use(express.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 = path4.join(this.rootDir, "src", "databases");
+  isCommonJS = typeof module !== "undefined" && !!module.exports;
+  isBuild = __dirname2.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 (!existsSync2(this.rootDir)) throw new MahameruError("Root directory does not exist");
+    if (!existsSync2(path4.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 (!existsSync2(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 = path4.join(process.cwd(), "node_modules", "tsx", "dist", this.isCommonJS ? "cli.cjs" : "cli.mjs");
+    const preInitScriptPath = `node_modules${path4.sep}mahameru${path4.sep}${this.isBuild ? "dist" : "src"}${path4.sep}lib${path4.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 = spawn2("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 = path4.join(this.rootDir, ".env");
+    const envDevelopmentPath = path4.join(this.rootDir, ".env.development");
+    if (!existsSync2(envDefaultPath)) await writeFile(envDefaultPath, "APP_NAME=Mahameru Node.js Framework", "utf-8");
+    if (!existsSync2(envDevelopmentPath)) {
+      const devEnv = ``;
+      await 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
+import { Column, CreateDateColumn, PrimaryGeneratedColumn } from "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([
+  PrimaryGeneratedColumn("uuid"),
+  _ts_metadata("design:type", String)
+], BaseEntity.prototype, "id", void 0);
+_ts_decorate([
+  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([
+  Column({
+    type: "datetime",
+    precision: 3,
+    default: null,
+    nullable: true
+  }),
+  _ts_metadata("design:type", Object)
+], BaseEntity.prototype, "updatedAt", void 0);
+_ts_decorate([
+  Column({
+    type: "boolean",
+    default: false
+  }),
+  _ts_metadata("design:type", Boolean)
+], BaseEntity.prototype, "isDisabled", void 0);
+
+// src/base-class/base.model.ts
+import { Like } from "typeorm";
+
+// src/index.ts
+var index_default = client_default;
+
+// src/cli/scripts/on-dev.ts
+import path5 from "path";
+async function onDev(cliOptions) {
+  try {
+    console.log("\x1B[36m%s\x1B[0m", "\u25B2 Mahameru - Starting development server...");
+    const root2 = process.cwd();
+    const configPath = pathToFileURL(path5.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 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.js.map