mahameru 0.0.0

package/dist/index.js

@@ -0,0 +1,783 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// 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/request.ts
+var MahameruRequest = class extends Request {
+  static {
+    __name(this, "MahameruRequest");
+  }
+};
+
+// src/response.ts
+var MahameruResponse = class extends Response {
+  static {
+    __name(this, "MahameruResponse");
+  }
+};
+
+// src/mahameru.ts
+import { writeFile } from "fs/promises";
+import path from "path";
+import { existsSync } from "fs";
+import { spawn } 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 APIErrorCode = {
+  BAD_REQUEST: "BAD_REQUEST",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  FORBIDDEN: "FORBIDDEN",
+  NOT_FOUND: "NOT_FOUND",
+  ROUTE_NOT_FOUND: "ROUTE_NOT_FOUND",
+  TOO_MANY_REQUESTS: "TOO_MANY_REQUESTS",
+  CONFLICT: "CONFLICT",
+  INTERNAL_SERVER_ERROR: "INTERNAL_SERVER_ERROR",
+  TOKEN_EXPIRED: "TOKEN_EXPIRED",
+  REFRESH_TOKEN_EXPIRED: "REFRESH_TOKEN_EXPIRED",
+  ACCESS_TOKEN_EXPIRED: "ACCESS_TOKEN_EXPIRED",
+  ACCESS_TOKEN_REQUIRED: "ACCESS_TOKEN_REQUIRED",
+  TOKEN_REFRESH_TOO_EARLY: "TOKEN_REFRESH_TOO_EARLY",
+  EMAIL_NOT_VERIFIED: "EMAIL_NOT_VERIFIED",
+  PHONE_NOT_VERIFIED: "PHONE_NOT_VERIFIED",
+  TOKEN_NOT_FOUND: "TOKEN_NOT_FOUND",
+  INVALID_TOKEN: "INVALID_TOKEN",
+  RESET_PASSWORD_TOKEN_USED: "RESET_PASSWORD_TOKEN_USED",
+  RESET_PASSWORD_NEEDED: "RESET_PASSWORD_NEEDED",
+  ROLE_DISABLED: "ROLE_DISABLED",
+  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+  SESSION_DISABLED: "SESSION_DISABLED",
+  INVALID_RESPONSE: "INVALID_RESPONSE",
+  UNKNOWN_CLIENT_ERROR: "UNKNOWN_CLIENT_ERROR",
+  INVALID_CREDENTIALS: "INVALID_CREDENTIALS",
+  VALIDATION_ERROR: "VALIDATION_ERROR"
+};
+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 = path.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 (!existsSync(this.rootDir)) throw new MahameruError("Root directory does not exist");
+    if (!existsSync(path.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 (!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 = path.join(process.cwd(), "node_modules", "tsx", "dist", this.isCommonJS ? "cli.cjs" : "cli.mjs");
+    const preInitScriptPath = `node_modules${path.sep}mahameru${path.sep}${this.isBuild ? "dist" : "src"}${path.sep}lib${path.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 = 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 = path.join(this.rootDir, ".env");
+    const envDevelopmentPath = path.join(this.rootDir, ".env.development");
+    if (!existsSync(envDefaultPath)) await writeFile(envDefaultPath, "APP_NAME=Mahameru Node.js Framework", "utf-8");
+    if (!existsSync(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.controller.ts
+var BaseController = class {
+  static {
+    __name(this, "BaseController");
+  }
+  defaultLimit = 10;
+  maxLimit = 100;
+  defaultOffset = 0;
+  defaultSortBy = "createdAt";
+  defaultSortDirection = "ASC";
+  allowedSortFields = [];
+  constructor(options) {
+    if (options) {
+      if (options.defaultLimit !== void 0) {
+        this.defaultLimit = options.defaultLimit;
+      }
+      if (options.maxLimit !== void 0) {
+        this.maxLimit = options.maxLimit;
+      }
+      if (options.defaultOffset !== void 0) {
+        this.defaultOffset = options.defaultOffset;
+      }
+      if (options.defaultSortBy !== void 0) {
+        this.defaultSortBy = options.defaultSortBy;
+      }
+      if (options.defaultSortDirection !== void 0) {
+        this.defaultSortDirection = options.defaultSortDirection;
+      }
+      if (options.allowedSortFields !== void 0) {
+        this.allowedSortFields = [
+          ...new Set(options.allowedSortFields)
+        ];
+      }
+    }
+  }
+  parseListQuery = /* @__PURE__ */ __name((request) => {
+    const { query: rawQuery, limit: rawLimit, offset: rawOffset, sortBy: rawSortBy, sortDirection: rawSortDirection } = request.query;
+    return {
+      query: this.parseQuery(rawQuery),
+      limit: this.parseLimit(rawLimit),
+      offset: this.parseOffset(rawOffset),
+      sortBy: this.parseSortBy(rawSortBy),
+      sortDirection: this.parseSortDirection(rawSortDirection)
+    };
+  }, "parseListQuery");
+  //@ts-ignore
+  parseTypeORMFindManyOptions(rawQuery) {
+    try {
+      if (typeof rawQuery === "string" && rawQuery.trim().length > 0) {
+        const result = JSON.parse(rawQuery);
+        if ("where" in result && typeof result.where === "object" && result.where !== null || "relations" in result && typeof result.relations === "object" && result.relations !== null || "order" in result && typeof result.order === "object" || "select" in result && typeof result.select === "object" || "take" in result || "skip" in result) {
+          if ("take" in result) result.take = parseInt(result.take);
+          if ("skip" in result) result.skip = parseInt(result.skip);
+          return result;
+        }
+      }
+    } catch {
+      return void 0;
+    }
+    return void 0;
+  }
+  parseQuery(rawQuery) {
+    if (Array.isArray(rawQuery)) {
+      rawQuery = rawQuery[0];
+    }
+    if (typeof rawQuery !== "string" || rawQuery.trim().length === 0) {
+      return void 0;
+    }
+    return rawQuery;
+  }
+  parseLimit(rawLimit) {
+    const parsed = this.parseInteger(rawLimit);
+    if (parsed === null || parsed < 1) {
+      return this.defaultLimit;
+    }
+    return Math.min(parsed, this.maxLimit);
+  }
+  parseOffset(rawOffset) {
+    const parsed = this.parseInteger(rawOffset);
+    if (parsed === null || parsed < 0) {
+      return this.defaultOffset;
+    }
+    return parsed;
+  }
+  parseSortBy(rawSortBy) {
+    if (Array.isArray(rawSortBy)) {
+      rawSortBy = rawSortBy[0];
+    }
+    if (typeof rawSortBy !== "string") {
+      return this.defaultSortBy;
+    }
+    if (!this.allowedSortFields.includes(rawSortBy)) {
+      return this.defaultSortBy;
+    }
+    return rawSortBy;
+  }
+  parseSortDirection(rawSortDirection) {
+    if (Array.isArray(rawSortDirection)) {
+      rawSortDirection = rawSortDirection[0];
+    }
+    if (typeof rawSortDirection !== "string") {
+      return this.defaultSortDirection;
+    }
+    return rawSortDirection.toLowerCase() === "desc" ? "DESC" : "ASC";
+  }
+  parseInteger(value) {
+    if (Array.isArray(value)) {
+      value = value[0];
+    }
+    if (typeof value !== "string" || value.trim().length === 0) {
+      return null;
+    }
+    const numberValue = Number(value);
+    if (!Number.isFinite(numberValue)) {
+      return null;
+    }
+    return Math.floor(numberValue);
+  }
+};
+
+// 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";
+var BaseModel = class _BaseModel {
+  static {
+    __name(this, "BaseModel");
+  }
+  dataSource;
+  entityTarget;
+  static defaultChunkSize = 500;
+  constructor(dataSource, entityTarget) {
+    this.dataSource = dataSource;
+    this.entityTarget = entityTarget;
+  }
+  getRepository(manager) {
+    return (manager ?? this.dataSource.manager).getRepository(this.entityTarget);
+  }
+  transaction(handler) {
+    return this.dataSource.transaction(handler);
+  }
+  async list(options, manager) {
+    let where = options.where;
+    if (typeof options.parsedListQuery.query === "string" && options.parsedListQuery.query.trim().length > 0 && options.searchFields && options.searchFields.length > 0) {
+      const search = `%${options.parsedListQuery.query.trim()}%`;
+      where = options.searchFields.map((field) => ({
+        [field]: Like(search)
+      }));
+    }
+    const order = options.parsedListQuery.sortBy ? {
+      [options.parsedListQuery.sortBy]: options.parsedListQuery.sortDirection ?? "ASC"
+    } : options.defaultOrder;
+    const [data, total] = await this.getRepository(manager).findAndCount({
+      where,
+      take: options.parsedListQuery.limit,
+      skip: options.parsedListQuery.offset,
+      order,
+      relations: options.relations
+    });
+    return {
+      data,
+      meta: {
+        total,
+        limit: options.parsedListQuery.limit,
+        offset: options.parsedListQuery.offset,
+        hasNext: options.parsedListQuery.offset + data.length < total
+      }
+    };
+  }
+  find(options, manager) {
+    return this.getRepository(manager).find(options);
+  }
+  findAndCount(options, manager) {
+    return this.getRepository(manager).findAndCount(options);
+  }
+  findOne(options, manager) {
+    return this.getRepository(manager).findOne(options);
+  }
+  findOneBy(where, manager) {
+    return this.getRepository(manager).findOneBy(where);
+  }
+  findOneById(id, manager) {
+    return this.getRepository(manager).findOne({
+      where: {
+        id
+      }
+    });
+  }
+  count(options, manager) {
+    return this.getRepository(manager).count(options);
+  }
+  countBy(where, manager) {
+    return this.getRepository(manager).countBy(where);
+  }
+  async exists(where, manager) {
+    const total = await this.countBy(where, manager);
+    return total > 0;
+  }
+  create(data, manager) {
+    return this.getRepository(manager).create(data);
+  }
+  save(data, manager) {
+    return this.getRepository(manager).save(data);
+  }
+  async createAndSave(data, manager) {
+    const repository = this.getRepository(manager);
+    const entity = repository.create(data);
+    return repository.save(entity);
+  }
+  async createBatch(data, options = {}, manager) {
+    const chunkSize = this.normalizeChunkSize(options.chunkSize);
+    const result = {
+      totalRecord: data.length,
+      totalAdded: 0,
+      failed: []
+    };
+    for (let index = 0; index < data.length; index += chunkSize) {
+      const chunk = data.slice(index, index + chunkSize);
+      try {
+        const saved = await this.saveBatch(chunk, manager);
+        result.totalAdded += saved.length;
+      } catch {
+        await this.saveBatchOneByOne(chunk, result, manager);
+      }
+    }
+    return result;
+  }
+  async update(where, data, manager) {
+    const repository = this.getRepository(manager);
+    if (!data.updatedAt) data.updatedAt = /* @__PURE__ */ new Date();
+    return repository.update(where, data);
+  }
+  updateById(id, data, manager) {
+    const repository = this.getRepository(manager);
+    if (!data.updatedAt) data.updatedAt = /* @__PURE__ */ new Date();
+    return repository.update(id, data);
+  }
+  async updateByIds(ids, data, manager) {
+    const repository = this.getRepository(manager);
+    if (!data.updatedAt) data.updatedAt = /* @__PURE__ */ new Date();
+    return repository.update(ids, {
+      ...data
+    });
+  }
+  async removeById(id, manager) {
+    const repository = this.getRepository(manager);
+    const entity = await this.findOneById(id, manager);
+    if (!entity) {
+      return null;
+    }
+    await repository.remove(entity);
+    return entity;
+  }
+  async softRemoveById(id, manager) {
+    const repository = this.getRepository(manager);
+    const entity = await this.findOneById(id, manager);
+    if (!entity) {
+      return null;
+    }
+    await repository.softRemove(entity);
+    return entity;
+  }
+  async restoreById(id, manager) {
+    const result = await this.getRepository(manager).restore(id);
+    return Boolean(result.affected);
+  }
+  async delete(where, manager) {
+    const result = await this.getRepository(manager).delete(where);
+    return Boolean(result.affected);
+  }
+  normalizeChunkSize(chunkSize) {
+    if (!chunkSize || chunkSize < 1) return _BaseModel.defaultChunkSize;
+    return Math.floor(chunkSize);
+  }
+  async saveBatch(data, manager) {
+    const repo = this.getRepository(manager);
+    const objects = repo.create(data);
+    return repo.save(objects, {
+      chunk: data.length
+    });
+  }
+  async saveBatchOneByOne(data, result, manager) {
+    for (const item of data) {
+      try {
+        await this.saveBatch([
+          item
+        ], manager);
+        result.totalAdded += 1;
+      } catch (error) {
+        result.failed.push({
+          data: item,
+          error
+        });
+      }
+    }
+  }
+};
+
+// src/base-class/base.service.ts
+var BaseService = class {
+  static {
+    __name(this, "BaseService");
+  }
+  constructor() {
+  }
+};
+
+// src/index.ts
+var index_default = client_default;
+export {
+  APIError,
+  APIErrorCode,
+  API_ERROR_STATUS,
+  BaseController,
+  BaseEntity,
+  BaseModel,
+  BaseService,
+  MahameruError,
+  MahameruRequest,
+  MahameruResponse,
+  createHttpServer,
+  index_default as default
+};
+//# sourceMappingURL=index.js.map