@forgedevstack/harbor 1.0.0

package/dist/index.es.js

@@ -0,0 +1,2094 @@
+var ee = Object.defineProperty;
+var te = (r, e, t) => e in r ? ee(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var c = (r, e, t) => te(r, typeof e != "symbol" ? e + "" : e, t);
+import q, { Router as ne } from "express";
+import { createServer as re } from "http";
+import { readFileSync as X, existsSync as I, writeFileSync as se } from "fs";
+import { resolve as R } from "path";
+import { c as A } from "./logger-D7aJSi62.mjs";
+import { s as kt } from "./logger-D7aJSi62.mjs";
+import { validateRequest as F } from "./validation/index.js";
+import { MongoValidator as Ht, createMongoSchema as Nt, createParamValidator as It, validateField as xt, validators as Dt } from "./validation/index.js";
+import { EventEmitter as oe } from "events";
+import { ObjectId as v } from "mongodb";
+import { D as jt, c as Lt } from "./manager-B6vqJgEn.mjs";
+const ie = [
+  "./harbor.config.json",
+  "./config/harbor.config.json",
+  "./.harbor/config.json"
+], x = {
+  PORT: "HARBOR_PORT",
+  HOST: "HARBOR_HOST",
+  LOG_LEVEL: "HARBOR_LOG_LEVEL",
+  CONFIG_PATH: "HARBOR_CONFIG_PATH"
+}, Xe = {
+  GET: "GET",
+  POST: "POST",
+  PUT: "PUT",
+  PATCH: "PATCH",
+  DELETE: "DELETE",
+  OPTIONS: "OPTIONS",
+  HEAD: "HEAD"
+}, p = {
+  OK: 200,
+  CREATED: 201,
+  NO_CONTENT: 204,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  CONFLICT: 409,
+  UNPROCESSABLE_ENTITY: 422,
+  TOO_MANY_REQUESTS: 429,
+  INTERNAL_SERVER_ERROR: 500,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504
+}, ae = {
+  200: "OK",
+  201: "Created",
+  204: "No Content",
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  409: "Conflict",
+  422: "Unprocessable Entity",
+  429: "Too Many Requests",
+  500: "Internal Server Error",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout"
+}, Je = {
+  JSON: "application/json",
+  HTML: "text/html",
+  TEXT: "text/plain",
+  FORM: "application/x-www-form-urlencoded",
+  MULTIPART: "multipart/form-data"
+}, Ze = {
+  CONTENT_TYPE: "Content-Type",
+  AUTHORIZATION: "Authorization",
+  ACCEPT: "Accept",
+  CACHE_CONTROL: "Cache-Control",
+  X_REQUEST_ID: "X-Request-ID",
+  X_RESPONSE_TIME: "X-Response-Time"
+}, ce = 3e3, de = "localhost", le = 3e4, ue = "10mb", D = {
+  server: {
+    port: ce,
+    host: de,
+    cors: {
+      enabled: !0,
+      origin: "*",
+      methods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
+      credentials: !1
+    },
+    bodyParser: {
+      json: !0,
+      urlencoded: !0,
+      limit: ue
+    },
+    trustProxy: !1
+  },
+  routes: {
+    prefix: "",
+    timeout: le,
+    defaultMiddleware: []
+  },
+  validation: {
+    adapter: "mongoose",
+    strictMode: !0,
+    sanitize: !0
+  },
+  errors: {
+    400: {
+      message: "Bad Request",
+      json: !0,
+      log: !1
+    },
+    401: {
+      message: "Unauthorized",
+      json: !0,
+      log: !0
+    },
+    403: {
+      message: "Forbidden",
+      json: !0,
+      log: !0
+    },
+    404: {
+      message: "Not Found",
+      json: !0,
+      log: !1
+    },
+    500: {
+      message: "Internal Server Error",
+      json: !0,
+      log: !0
+    },
+    default: {
+      message: "An error occurred",
+      json: !0,
+      log: !0
+    }
+  },
+  logger: {
+    enabled: !0,
+    level: "info",
+    format: "text",
+    output: "console"
+  }
+}, he = 1e4, B = A("config");
+function me(r) {
+  const e = fe(r);
+  if (!e)
+    return B.info("No config file found, using defaults"), V(D);
+  try {
+    const t = X(e, "utf-8"), n = JSON.parse(t), s = z(
+      D,
+      n
+    );
+    return B.info("Config loaded", { path: e }), V(s);
+  } catch (t) {
+    return B.error("Failed to load config", t), V(D);
+  }
+}
+function et(r) {
+  return z(
+    D,
+    r
+  );
+}
+function fe(r) {
+  if (r) {
+    const t = R(process.cwd(), r);
+    return I(t) ? t : null;
+  }
+  const e = process.env[x.CONFIG_PATH];
+  if (e) {
+    const t = R(process.cwd(), e);
+    if (I(t))
+      return t;
+  }
+  for (const t of ie) {
+    const n = R(process.cwd(), t);
+    if (I(n))
+      return n;
+  }
+  return null;
+}
+function V(r) {
+  const e = process.env[x.PORT], t = process.env[x.HOST], n = process.env[x.LOG_LEVEL];
+  return e && (r.server.port = parseInt(e, 10)), t && (r.server.host = t), n && (r.logger.level = n), r;
+}
+function z(r, e) {
+  const t = { ...r };
+  for (const n in e)
+    if (Object.prototype.hasOwnProperty.call(e, n)) {
+      const s = e[n], o = r[n];
+      s !== null && typeof s == "object" && !Array.isArray(s) && o !== null && typeof o == "object" && !Array.isArray(o) ? t[n] = z(
+        o,
+        s
+      ) : s !== void 0 && (t[n] = s);
+    }
+  return t;
+}
+const ge = {
+  // Server
+  "server.starting": "Server starting...",
+  "server.started": "Server started on http://{host}:{port}",
+  "server.stopping": "Server stopping...",
+  "server.stopped": "Server stopped",
+  "server.alreadyRunning": "Server is already running",
+  "server.error": "Server error",
+  "server.gracefulShutdown": "Received {signal}, shutting down gracefully",
+  // Router
+  "router.registered": "Registered route: {method} {path}",
+  "router.missingRequired": "Route must have path, method, and handler",
+  // Validation
+  "validation.failed": "Validation failed",
+  "validation.required": "{field} is required",
+  "validation.typeMismatch": "{field} must be of type {type}",
+  "validation.minValue": "{field} must be at least {min}",
+  "validation.maxValue": "{field} must be at most {max}",
+  "validation.minLength": "{field} must be at least {min} characters",
+  "validation.maxLength": "{field} must be at most {max} characters",
+  "validation.pattern": "{field} does not match the required pattern",
+  "validation.enum": "{field} must be one of: {values}",
+  "validation.invalidObjectId": "{field} is not a valid ObjectId",
+  "validation.invalidEmail": "{field} is not a valid email address",
+  "validation.invalidUrl": "{field} is not a valid URL",
+  "validation.invalidDate": "{field} is not a valid date",
+  "validation.customFailed": "{field} failed custom validation",
+  // Errors
+  "errors.badRequest": "Bad Request",
+  "errors.unauthorized": "Unauthorized",
+  "errors.forbidden": "Forbidden",
+  "errors.notFound": "Not Found",
+  "errors.conflict": "Conflict",
+  "errors.tooManyRequests": "Too Many Requests",
+  "errors.internal": "Internal Server Error",
+  "errors.timeout": "Request timeout",
+  "errors.default": "An error occurred",
+  // Config
+  "config.notFound": "No config file found, using defaults",
+  "config.loaded": "Config loaded from {path}",
+  "config.loadFailed": "Failed to load config",
+  // Docker
+  "docker.containerStarted": "Container started: {name}",
+  "docker.containerStopped": "Container stopped: {name}",
+  "docker.containerRestarted": "Container restarted: {name}",
+  "docker.containerRemoved": "Container removed: {name}",
+  "docker.imageBuilt": "Image built: {name}:{tag}",
+  "docker.imagePushed": "Image pushed: {name}",
+  "docker.imagePulled": "Image pulled: {name}:{tag}",
+  "docker.composeUp": "Docker Compose up completed",
+  "docker.composeDown": "Docker Compose down completed",
+  "docker.commandFailed": "Docker command failed: {command}",
+  // Changelog
+  "changelog.loaded": "Changelog loaded with {count} entries",
+  "changelog.saved": "Changelog saved to {path}",
+  "changelog.released": "Released version {version}",
+  "changelog.notFound": "No changelog file found, starting fresh",
+  // Portal
+  "portal.generated": "Portal generated at {path}",
+  "portal.generating": "Generating documentation portal...",
+  // Logger
+  "logger.levelChanged": "Log level changed to {level}",
+  // HTTP Logger (Morgan-like)
+  "http.request": "{method} {url} {status} {duration}ms",
+  "http.requestStart": "Incoming request: {method} {url}",
+  "http.requestEnd": "Request completed: {method} {url} - {status} in {duration}ms",
+  // CLI
+  "cli.init.success": "Harbor project initialized!",
+  "cli.init.configExists": "harbor.config.json already exists",
+  "cli.init.created": "Created {file}",
+  "cli.docs.generating": "Generating API documentation...",
+  "cli.docs.success": "Documentation generated successfully",
+  "cli.version": "Harbor v{version}",
+  "cli.unknownCommand": "Unknown command: {command}",
+  // Database
+  "database.connected": "Connected to MongoDB at {uri}",
+  "database.disconnected": "Disconnected from MongoDB",
+  "database.connecting": "Connecting to MongoDB...",
+  "database.connectionFailed": "Failed to connect to MongoDB: {error}",
+  "database.notConnected": "Not connected to database. Call harbor.connect() first.",
+  "database.modelCreated": "Model created: {name}",
+  "database.documentSaved": "Document saved: {id}",
+  "database.documentDeleted": "Document deleted: {id}",
+  "database.validationFailed": "Validation failed: {errors}",
+  "database.queryExecuted": "Query executed: {operation} on {collection}",
+  "database.indexCreated": "Index created: {name}",
+  "database.transactionStarted": "Transaction started",
+  "database.transactionCommitted": "Transaction committed",
+  "database.transactionAborted": "Transaction aborted"
+}, pe = {
+  // Server
+  "server.starting": "השרת מופעל...",
+  "server.started": "השרת פועל בכתובת http://{host}:{port}",
+  "server.stopping": "השרת נעצר...",
+  "server.stopped": "השרת נעצר",
+  "server.alreadyRunning": "השרת כבר פועל",
+  "server.error": "שגיאת שרת",
+  "server.gracefulShutdown": "התקבל {signal}, מכבה בצורה מסודרת",
+  // Router
+  "router.registered": "נרשם נתיב: {method} {path}",
+  "router.missingRequired": "נתיב חייב לכלול path, method ו-handler",
+  // Validation
+  "validation.failed": "האימות נכשל",
+  "validation.required": "{field} הוא שדה חובה",
+  "validation.typeMismatch": "{field} חייב להיות מסוג {type}",
+  "validation.minValue": "{field} חייב להיות לפחות {min}",
+  "validation.maxValue": "{field} חייב להיות לכל היותר {max}",
+  "validation.minLength": "{field} חייב להכיל לפחות {min} תווים",
+  "validation.maxLength": "{field} חייב להכיל לכל היותר {max} תווים",
+  "validation.pattern": "{field} לא תואם לתבנית הנדרשת",
+  "validation.enum": "{field} חייב להיות אחד מ: {values}",
+  "validation.invalidObjectId": "{field} אינו ObjectId תקין",
+  "validation.invalidEmail": "{field} אינה כתובת אימייל תקינה",
+  "validation.invalidUrl": "{field} אינו URL תקין",
+  "validation.invalidDate": "{field} אינו תאריך תקין",
+  "validation.customFailed": "{field} נכשל באימות מותאם אישית",
+  // Errors
+  "errors.badRequest": "בקשה שגויה",
+  "errors.unauthorized": "לא מורשה",
+  "errors.forbidden": "גישה נדחתה",
+  "errors.notFound": "לא נמצא",
+  "errors.conflict": "התנגשות",
+  "errors.tooManyRequests": "יותר מדי בקשות",
+  "errors.internal": "שגיאת שרת פנימית",
+  "errors.timeout": "הבקשה פגה",
+  "errors.default": "אירעה שגיאה",
+  // Config
+  "config.notFound": "קובץ הגדרות לא נמצא, משתמש בברירת מחדל",
+  "config.loaded": "הגדרות נטענו מ-{path}",
+  "config.loadFailed": "נכשל בטעינת הגדרות",
+  // Docker
+  "docker.containerStarted": "קונטיינר הופעל: {name}",
+  "docker.containerStopped": "קונטיינר נעצר: {name}",
+  "docker.containerRestarted": "קונטיינר הופעל מחדש: {name}",
+  "docker.containerRemoved": "קונטיינר הוסר: {name}",
+  "docker.imageBuilt": "תמונה נבנתה: {name}:{tag}",
+  "docker.imagePushed": "תמונה הועלתה: {name}",
+  "docker.imagePulled": "תמונה הורדה: {name}:{tag}",
+  "docker.composeUp": "Docker Compose הופעל בהצלחה",
+  "docker.composeDown": "Docker Compose נעצר בהצלחה",
+  "docker.commandFailed": "פקודת Docker נכשלה: {command}",
+  // Changelog
+  "changelog.loaded": "יומן שינויים נטען עם {count} רשומות",
+  "changelog.saved": "יומן שינויים נשמר ב-{path}",
+  "changelog.released": "שוחררה גרסה {version}",
+  "changelog.notFound": "קובץ יומן שינויים לא נמצא, מתחיל מחדש",
+  // Portal
+  "portal.generated": "פורטל נוצר ב-{path}",
+  "portal.generating": "מייצר פורטל תיעוד...",
+  // Logger
+  "logger.levelChanged": "רמת הלוג שונתה ל-{level}",
+  // HTTP Logger
+  "http.request": "{method} {url} {status} {duration}ms",
+  "http.requestStart": "בקשה נכנסת: {method} {url}",
+  "http.requestEnd": "בקשה הושלמה: {method} {url} - {status} תוך {duration}ms",
+  // CLI
+  "cli.init.success": "פרויקט Harbor אותחל בהצלחה!",
+  "cli.init.configExists": "harbor.config.json כבר קיים",
+  "cli.init.created": "נוצר {file}",
+  "cli.docs.generating": "מייצר תיעוד API...",
+  "cli.docs.success": "התיעוד נוצר בהצלחה",
+  "cli.version": "Harbor גרסה {version}",
+  "cli.unknownCommand": "פקודה לא מוכרת: {command}",
+  // Database
+  "database.connected": "מחובר ל-MongoDB ב-{uri}",
+  "database.disconnected": "נותק מ-MongoDB",
+  "database.connecting": "מתחבר ל-MongoDB...",
+  "database.connectionFailed": "החיבור ל-MongoDB נכשל: {error}",
+  "database.notConnected": "לא מחובר למסד נתונים. קרא ל-harbor.connect() קודם.",
+  "database.modelCreated": "מודל נוצר: {name}",
+  "database.documentSaved": "מסמך נשמר: {id}",
+  "database.documentDeleted": "מסמך נמחק: {id}",
+  "database.validationFailed": "האימות נכשל: {errors}",
+  "database.queryExecuted": "שאילתה בוצעה: {operation} על {collection}",
+  "database.indexCreated": "אינדקס נוצר: {name}",
+  "database.transactionStarted": "טרנזקציה התחילה",
+  "database.transactionCommitted": "טרנזקציה אושרה",
+  "database.transactionAborted": "טרנזקציה בוטלה"
+}, E = {
+  en: ge,
+  he: pe
+};
+let M = "en";
+function tt(r) {
+  if (!E[r]) {
+    console.warn(`Locale "${r}" not found, falling back to "en"`), M = "en";
+    return;
+  }
+  M = r;
+}
+function nt() {
+  return M;
+}
+function rt() {
+  return Object.keys(E);
+}
+function C(r, e) {
+  let n = (E[M] ?? E.en)[r] ?? E.en[r] ?? r;
+  if (e)
+    for (const [s, o] of Object.entries(e))
+      n = n.replace(new RegExp(`{${s}}`, "g"), String(o ?? ""));
+  return n;
+}
+function st(r, e) {
+  E[r] || (E[r] = {}), Object.assign(E[r], e);
+}
+function ot(r, e) {
+  E[r] = e;
+}
+const _e = A("router");
+function K(r, e) {
+  const t = ne();
+  return r.middleware && r.middleware.forEach((n) => t.use(n)), r.routes && r.routes.forEach((n) => {
+    ye(t, n, e);
+  }), t;
+}
+function ye(r, e, t) {
+  const n = e.method.toLowerCase(), s = we(e, t);
+  r[n](e.path, ...s), _e.debug(C("router.registered", { method: e.method, path: e.path }));
+}
+function we(r, e) {
+  const t = [], n = r.options ?? {};
+  return n.pre && n.pre.forEach((s) => {
+    t.push(ve(s));
+  }), n.validation && t.push(Ce(n.validation, e)), n.timeout && t.push(Te(n.timeout)), t.push(be(r.handler, n)), t;
+}
+function ve(r) {
+  return async (e, t, n) => {
+    try {
+      await r(e, t, n);
+    } catch (s) {
+      n(s);
+    }
+  };
+}
+function be(r, e) {
+  return async (t, n, s) => {
+    try {
+      const o = await r(t, n);
+      if (e.post && e.post.length > 0)
+        for (const i of e.post)
+          await i(t, n, o);
+      !n.headersSent && o !== void 0 && n.json({
+        success: !0,
+        data: o
+      });
+    } catch (o) {
+      s(o);
+    }
+  };
+}
+function Ce(r, e) {
+  return async (t, n, s) => {
+    try {
+      const o = {};
+      if (r.params) {
+        const i = await F(r.params, t.params, e.validation);
+        if (!i.valid) {
+          n.status(p.BAD_REQUEST).json({
+            success: !1,
+            error: {
+              message: C("validation.failed"),
+              details: i.errors
+            }
+          });
+          return;
+        }
+        o.params = i.data;
+      }
+      if (r.query) {
+        const i = await F(r.query, t.query, e.validation);
+        if (!i.valid) {
+          n.status(p.BAD_REQUEST).json({
+            success: !1,
+            error: {
+              message: C("validation.failed"),
+              details: i.errors
+            }
+          });
+          return;
+        }
+        o.query = i.data;
+      }
+      if (r.body) {
+        const i = await F(r.body, t.body, e.validation);
+        if (!i.valid) {
+          n.status(p.BAD_REQUEST).json({
+            success: !1,
+            error: {
+              message: C("validation.failed"),
+              details: i.errors
+            }
+          });
+          return;
+        }
+        o.body = i.data;
+      }
+      t.validated = o, s();
+    } catch (o) {
+      s(o);
+    }
+  };
+}
+function Te(r) {
+  return (e, t, n) => {
+    const s = setTimeout(() => {
+      t.headersSent || t.status(p.GATEWAY_TIMEOUT).json({
+        success: !1,
+        error: {
+          message: C("errors.timeout")
+        }
+      });
+    }, r);
+    t.on("finish", () => clearTimeout(s)), t.on("close", () => clearTimeout(s)), n();
+  };
+}
+function it(r, e, t) {
+  return P("GET", r, e, t);
+}
+function at(r, e, t) {
+  return P("POST", r, e, t);
+}
+function ct(r, e, t) {
+  return P("PUT", r, e, t);
+}
+function dt(r, e, t) {
+  return P("PATCH", r, e, t);
+}
+function lt(r, e, t) {
+  return P("DELETE", r, e, t);
+}
+function ut(r, e, t, n) {
+  return P(r, e, t, n);
+}
+function P(r, e, t, n) {
+  return {
+    path: e,
+    method: r,
+    handler: t,
+    options: n ? {
+      pre: n.pre,
+      post: n.post,
+      validation: n.validation,
+      timeout: n.timeout
+    } : void 0
+  };
+}
+class J {
+  constructor() {
+    c(this, "_route", {});
+    c(this, "_options", {});
+  }
+  static create() {
+    return new J();
+  }
+  path(e) {
+    return this._route.path = e, this;
+  }
+  method(e) {
+    return this._route.method = e, this;
+  }
+  get(e) {
+    return this.method("GET").path(e);
+  }
+  post(e) {
+    return this.method("POST").path(e);
+  }
+  put(e) {
+    return this.method("PUT").path(e);
+  }
+  patch(e) {
+    return this.method("PATCH").path(e);
+  }
+  delete(e) {
+    return this.method("DELETE").path(e);
+  }
+  handler(e) {
+    if (this._route.handler = e, !this._route.path || !this._route.method || !this._route.handler)
+      throw new Error(C("router.missingRequired"));
+    return {
+      path: this._route.path,
+      method: this._route.method,
+      handler: this._route.handler,
+      options: Object.keys(this._options).length > 0 ? this._options : void 0
+    };
+  }
+  pre(...e) {
+    return this._options.pre = [...this._options.pre ?? [], ...e], this;
+  }
+  postFn(...e) {
+    return this._options.post = [...this._options.post ?? [], ...e], this;
+  }
+  validate(e) {
+    return this._options.validation = e, this;
+  }
+  timeout(e) {
+    return this._options.timeout = e, this;
+  }
+  rateLimit(e) {
+    return this._options.rateLimit = e, this;
+  }
+  auth(e) {
+    return this._options.auth = e, this;
+  }
+  cache(e) {
+    return this._options.cache = e, this;
+  }
+  // Legacy .build() still works for backwards compatibility
+  build() {
+    if (!this._route.path || !this._route.method || !this._route.handler)
+      throw new Error(C("router.missingRequired"));
+    return {
+      path: this._route.path,
+      method: this._route.method,
+      handler: this._route.handler,
+      options: Object.keys(this._options).length > 0 ? this._options : void 0
+    };
+  }
+}
+const Oe = A("error");
+class O extends Error {
+  constructor(t, n = p.INTERNAL_SERVER_ERROR, s) {
+    super(t);
+    c(this, "statusCode");
+    c(this, "code");
+    c(this, "details");
+    c(this, "isOperational");
+    this.name = "HarborError", this.statusCode = n, this.code = s == null ? void 0 : s.code, this.details = s == null ? void 0 : s.details, this.isOperational = (s == null ? void 0 : s.isOperational) ?? !0, Error.captureStackTrace(this, this.constructor);
+  }
+  static badRequest(t, n) {
+    return new O(
+      t ?? "Bad Request",
+      p.BAD_REQUEST,
+      { code: "BAD_REQUEST", details: n }
+    );
+  }
+  static unauthorized(t) {
+    return new O(
+      t ?? "Unauthorized",
+      p.UNAUTHORIZED,
+      { code: "UNAUTHORIZED" }
+    );
+  }
+  static forbidden(t) {
+    return new O(
+      t ?? "Forbidden",
+      p.FORBIDDEN,
+      { code: "FORBIDDEN" }
+    );
+  }
+  static notFound(t) {
+    return new O(
+      t ?? "Not Found",
+      p.NOT_FOUND,
+      { code: "NOT_FOUND" }
+    );
+  }
+  static conflict(t, n) {
+    return new O(
+      t ?? "Conflict",
+      p.CONFLICT,
+      { code: "CONFLICT", details: n }
+    );
+  }
+  static internal(t) {
+    return new O(
+      t ?? "Internal Server Error",
+      p.INTERNAL_SERVER_ERROR,
+      { code: "INTERNAL_ERROR", isOperational: !1 }
+    );
+  }
+  static tooManyRequests(t) {
+    return new O(
+      t ?? "Too Many Requests",
+      p.TOO_MANY_REQUESTS,
+      { code: "RATE_LIMIT_EXCEEDED" }
+    );
+  }
+  toJSON() {
+    return {
+      success: !1,
+      error: {
+        message: this.message,
+        code: this.code,
+        statusCode: this.statusCode,
+        details: this.details
+      }
+    };
+  }
+}
+function Ee(r) {
+  const e = r.errors;
+  return (t, n, s, o) => {
+    const i = t.statusCode ?? p.INTERNAL_SERVER_ERROR, a = Se(i, e);
+    if ((a == null ? void 0 : a.log) !== !1 && r.logger.enabled && Oe.error(`${n.method} ${n.path} - ${t.message}`, t), s.headersSent)
+      return;
+    if (a != null && a.redirect) {
+      s.redirect(a.redirect);
+      return;
+    }
+    const h = Ae(t, i, a);
+    (a == null ? void 0 : a.json) !== !1 ? s.status(i).json(h) : s.status(i).send(h.error.message);
+  };
+}
+function Se(r, e) {
+  const t = r.toString();
+  return e[t] ?? e.default;
+}
+function Ae(r, e, t) {
+  return r instanceof O ? r.toJSON() : {
+    success: !1,
+    error: {
+      message: (t == null ? void 0 : t.message) ?? r.message ?? ae[e] ?? "An error occurred",
+      statusCode: e
+    }
+  };
+}
+const S = A("server");
+function ht(r = {}) {
+  const e = me(r.configPath), t = q();
+  let n = null, s = "stopped", o = null;
+  const i = [];
+  Pe(t, e);
+  const a = {
+    app: t,
+    server: n,
+    config: e,
+    async start() {
+      if (s === "running")
+        return S.warn("Server is already running"), a.getInfo();
+      s = "starting";
+      const h = r.port ?? e.server.port, g = r.host ?? e.server.host ?? "localhost";
+      return new Promise((w, b) => {
+        try {
+          n = re(t), a.server = n, n.listen(h, g, () => {
+            var l;
+            s = "running", o = /* @__PURE__ */ new Date();
+            const d = a.getInfo();
+            S.info(`Server started on http://${g}:${h}`), (l = r.onReady) == null || l.call(r, d), w(d);
+          }), n.on("error", (d) => {
+            var l;
+            s = "error", S.error("Server error", d), (l = r.onError) == null || l.call(r, d), b(d);
+          }), Re(a);
+        } catch (d) {
+          s = "error", b(d);
+        }
+      });
+    },
+    async stop() {
+      if (!(!n || s === "stopped"))
+        return s = "stopping", new Promise((h, g) => {
+          const w = setTimeout(() => {
+            n == null || n.close(), h();
+          }, he);
+          n.close((b) => {
+            clearTimeout(w), b ? (S.error("Error stopping server", b), g(b)) : (s = "stopped", o = null, S.info("Server stopped"), h());
+          });
+        });
+    },
+    async restart() {
+      return await a.stop(), a.start();
+    },
+    addRoute(h) {
+      i.push(h);
+      const g = K({ routes: [h] }, e);
+      t.use(g);
+    },
+    addRouteGroup(h) {
+      i.push(...h.routes);
+      const g = K({
+        prefix: h.prefix,
+        routes: h.routes,
+        middleware: h.middleware
+      }, e);
+      t.use(h.prefix, g);
+    },
+    addMiddleware(h) {
+      t.use(h);
+    },
+    getInfo() {
+      const h = r.port ?? e.server.port, g = r.host ?? e.server.host ?? "localhost";
+      return {
+        port: h,
+        host: g,
+        uptime: o ? Date.now() - o.getTime() : 0,
+        startedAt: o,
+        routes: i.map((w) => ({
+          path: w.path,
+          method: w.method,
+          middleware: []
+        })),
+        status: s
+      };
+    }
+  };
+  return r.autoStart !== !1 && a.start().catch((h) => {
+    S.error("Failed to auto-start server", h);
+  }), a;
+}
+function Pe(r, e) {
+  var n, s, o;
+  (n = e.server.bodyParser) != null && n.json && r.use(q.json({ limit: e.server.bodyParser.limit })), (s = e.server.bodyParser) != null && s.urlencoded && r.use(q.urlencoded({
+    extended: !0,
+    limit: e.server.bodyParser.limit
+  })), (o = e.server.cors) != null && o.enabled && r.use($e(e.server.cors)), r.use(ke());
+  const t = Ee(e);
+  r.use(t);
+}
+function $e(r) {
+  return (e, t, n) => {
+    var o;
+    const s = r.origin;
+    if (s === !0 || s === "*")
+      t.setHeader("Access-Control-Allow-Origin", "*");
+    else if (typeof s == "string")
+      t.setHeader("Access-Control-Allow-Origin", s);
+    else if (Array.isArray(s)) {
+      const i = e.headers.origin;
+      i && s.includes(i) && t.setHeader("Access-Control-Allow-Origin", i);
+    }
+    if (t.setHeader(
+      "Access-Control-Allow-Methods",
+      ((o = r.methods) == null ? void 0 : o.join(", ")) ?? "GET,POST,PUT,PATCH,DELETE,OPTIONS"
+    ), r.allowedHeaders ? t.setHeader("Access-Control-Allow-Headers", r.allowedHeaders.join(", ")) : t.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization"), r.credentials && t.setHeader("Access-Control-Allow-Credentials", "true"), e.method === "OPTIONS") {
+      t.status(204).end();
+      return;
+    }
+    n();
+  };
+}
+function ke() {
+  return (r, e, t) => {
+    r.startTime = Date.now(), r.harborContext = {}, e.success = function(n, s = 200) {
+      e.status(s).json({
+        success: !0,
+        data: n
+      });
+    }, e.error = function(n, s = 500, o) {
+      e.status(s).json({
+        success: !1,
+        error: {
+          message: n,
+          details: o
+        }
+      });
+    }, t();
+  };
+}
+function Re(r) {
+  ["SIGTERM", "SIGINT"].forEach((t) => {
+    process.on(t, async () => {
+      S.info(`Received ${t}, shutting down gracefully`), await r.stop(), process.exit(0);
+    });
+  });
+}
+class Z {
+  constructor(e, t) {
+    c(this, "_definition");
+    c(this, "_options");
+    c(this, "_paths", /* @__PURE__ */ new Map());
+    c(this, "_virtuals", /* @__PURE__ */ new Map());
+    c(this, "_methods", /* @__PURE__ */ new Map());
+    c(this, "_statics", /* @__PURE__ */ new Map());
+    c(this, "_preHooks", /* @__PURE__ */ new Map());
+    c(this, "_postHooks", /* @__PURE__ */ new Map());
+    c(this, "_indexes", []);
+    c(this, "_plugins", []);
+    // Public accessors for methods and statics
+    c(this, "methods", {});
+    c(this, "statics", {});
+    c(this, "virtuals", {});
+    if (this._definition = e, this._options = {
+      timestamps: !1,
+      strict: !0,
+      strictQuery: !1,
+      _id: !0,
+      id: !0,
+      versionKey: "__v",
+      autoIndex: !0,
+      autoCreate: !0,
+      minimize: !0,
+      ...t
+    }, this._parseDefinition(e), this._options._id && this._paths.set("_id", { type: "ObjectId", required: !1 }), this._options.timestamps) {
+      const n = typeof this._options.timestamps == "object" ? this._options.timestamps.createdAt === !1 ? null : this._options.timestamps.createdAt || "createdAt" : "createdAt", s = typeof this._options.timestamps == "object" ? this._options.timestamps.updatedAt === !1 ? null : this._options.timestamps.updatedAt || "updatedAt" : "updatedAt";
+      n && this._paths.set(n, { type: "Date", required: !1 }), s && this._paths.set(s, { type: "Date", required: !1 });
+    }
+    if (this._options.versionKey) {
+      const n = typeof this._options.versionKey == "string" ? this._options.versionKey : "__v";
+      this._paths.set(n, { type: "Number", default: 0 });
+    }
+    this.methods = new Proxy({}, {
+      set: (n, s, o) => (this._methods.set(s, o), !0),
+      get: (n, s) => this._methods.get(s)
+    }), this.statics = new Proxy({}, {
+      set: (n, s, o) => (this._statics.set(s, o), !0),
+      get: (n, s) => this._statics.get(s)
+    });
+  }
+  _parseDefinition(e, t = "") {
+    for (const [n, s] of Object.entries(e)) {
+      const o = t ? `${t}.${n}` : n;
+      if (typeof s == "string")
+        this._paths.set(o, { type: s });
+      else if (typeof s == "object" && s !== null) {
+        const i = s;
+        "type" in i ? typeof i.type == "string" ? this._paths.set(o, i) : Array.isArray(i.type) ? this._paths.set(o, { ...i, type: "Array" }) : typeof i.type == "object" && (this._paths.set(o, { type: "Object" }), this._parseDefinition(i.type, o)) : (this._paths.set(o, { type: "Object" }), this._parseDefinition(s, o));
+      }
+    }
+  }
+  // Add additional fields to schema
+  add(e, t) {
+    return this._parseDefinition(e, t), this;
+  }
+  // Get path definition
+  path(e) {
+    return this._paths.get(e);
+  }
+  // Get all paths
+  paths() {
+    return this._paths;
+  }
+  // Define virtual field
+  virtual(e) {
+    return new He(this, e);
+  }
+  // Define instance method
+  method(e, t) {
+    return this._methods.set(e, t), this;
+  }
+  // Define static method
+  static(e, t) {
+    return this._statics.set(e, t), this;
+  }
+  // Pre hook
+  pre(e, t) {
+    const n = Array.isArray(e) ? e : [e];
+    for (const s of n) {
+      const o = this._preHooks.get(s) || [];
+      o.push(t), this._preHooks.set(s, o);
+    }
+    return this;
+  }
+  // Post hook
+  post(e, t) {
+    const n = Array.isArray(e) ? e : [e];
+    for (const s of n) {
+      const o = this._postHooks.get(s) || [];
+      o.push(t), this._postHooks.set(s, o);
+    }
+    return this;
+  }
+  // Define index
+  index(e, t) {
+    return this._indexes.push({ fields: e, options: t }), this;
+  }
+  // Plugin support
+  plugin(e, t) {
+    return this._plugins.push({ fn: e, options: t }), e(this, t), this;
+  }
+  // Load class methods as schema methods
+  loadClass(e) {
+    const t = e.prototype;
+    for (const n of Object.getOwnPropertyNames(t)) {
+      if (n === "constructor") continue;
+      const s = Object.getOwnPropertyDescriptor(t, n);
+      if (s != null && s.get)
+        this._virtuals.set(n, { get: s.get });
+      else if (s != null && s.set) {
+        const o = this._virtuals.get(n) || {};
+        this._virtuals.set(n, { ...o, set: s.set });
+      } else typeof (s == null ? void 0 : s.value) == "function" && this._methods.set(n, s.value);
+    }
+    for (const n of Object.getOwnPropertyNames(e)) {
+      if (["length", "prototype", "name"].includes(n)) continue;
+      const s = e[n];
+      typeof s == "function" && this._statics.set(n, s);
+    }
+    return this;
+  }
+  // Clone schema
+  clone() {
+    const e = new Z({}, this._options);
+    return e._paths = new Map(this._paths), e._virtuals = new Map(this._virtuals), e._methods = new Map(this._methods), e._statics = new Map(this._statics), e._preHooks = new Map(this._preHooks), e._postHooks = new Map(this._postHooks), e._indexes = [...this._indexes], e;
+  }
+  // Getters
+  get options() {
+    return this._options;
+  }
+  get definition() {
+    return this._definition;
+  }
+  getMethods() {
+    return this._methods;
+  }
+  getStatics() {
+    return this._statics;
+  }
+  getVirtuals() {
+    return this._virtuals;
+  }
+  getPreHooks() {
+    return this._preHooks;
+  }
+  getPostHooks() {
+    return this._postHooks;
+  }
+  getIndexes() {
+    return this._indexes;
+  }
+  // Validate document against schema
+  async validate(e) {
+    const t = [];
+    for (const [n, s] of this._paths) {
+      const o = this._getNestedValue(e, n), i = await this._validateField(n, o, s);
+      t.push(...i);
+    }
+    return t.length > 0 ? { valid: !1, errors: t } : { valid: !0 };
+  }
+  _getNestedValue(e, t) {
+    return t.split(".").reduce((n, s) => n == null ? void 0 : n[s], e);
+  }
+  async _validateField(e, t, n) {
+    const s = [];
+    return n.required && t == null ? (s.push({ path: e, message: `${e} is required` }), s) : t == null ? s : this._validateType(t, n.type) ? (n.type === "String" && typeof t == "string" && (n.minLength && t.length < n.minLength && s.push({ path: e, message: `${e} must be at least ${n.minLength} characters` }), n.maxLength && t.length > n.maxLength && s.push({ path: e, message: `${e} must be at most ${n.maxLength} characters` }), n.match && !n.match.test(t) && s.push({ path: e, message: `${e} does not match required pattern` }), n.enum && !n.enum.includes(t) && s.push({ path: e, message: `${e} must be one of: ${n.enum.join(", ")}` })), n.type === "Number" && typeof t == "number" && (n.min !== void 0 && t < n.min && s.push({ path: e, message: `${e} must be at least ${n.min}` }), n.max !== void 0 && t > n.max && s.push({ path: e, message: `${e} must be at most ${n.max}` })), n.validate && (await n.validate.validator(t) || s.push({ path: e, message: n.validate.message || `${e} failed validation` })), s) : (s.push({ path: e, message: `${e} must be of type ${n.type}` }), s);
+  }
+  _validateType(e, t) {
+    switch (t) {
+      case "String":
+        return typeof e == "string";
+      case "Number":
+        return typeof e == "number" && !isNaN(e);
+      case "Boolean":
+        return typeof e == "boolean";
+      case "Date":
+        return e instanceof Date || typeof e == "string" && !isNaN(Date.parse(e));
+      case "ObjectId":
+        return typeof e == "string" && /^[0-9a-fA-F]{24}$/.test(e);
+      case "Array":
+        return Array.isArray(e);
+      case "Object":
+      case "Mixed":
+        return typeof e == "object" && e !== null;
+      case "Buffer":
+        return Buffer.isBuffer(e);
+      default:
+        return !0;
+    }
+  }
+  // Apply transformations (lowercase, uppercase, trim)
+  transformValue(e, t) {
+    const n = this._paths.get(e);
+    if (!n || typeof t != "string") return t;
+    let s = t;
+    return n.lowercase && (s = s.toLowerCase()), n.uppercase && (s = s.toUpperCase()), n.trim && (s = s.trim()), s;
+  }
+  // Get default value for a field
+  getDefault(e) {
+    const t = this._paths.get(e);
+    if (!(!t || t.default === void 0))
+      return typeof t.default == "function" ? t.default() : t.default;
+  }
+}
+class He {
+  constructor(e, t) {
+    c(this, "schema");
+    c(this, "name");
+    this.schema = e, this.name = t;
+  }
+  get(e) {
+    const t = this.schema.getVirtuals(), n = t.get(this.name) || {};
+    return t.set(this.name, { ...n, get: e }), this;
+  }
+  set(e) {
+    const t = this.schema.getVirtuals(), n = t.get(this.name) || {};
+    return t.set(this.name, { ...n, set: e }), this;
+  }
+}
+class Ne extends oe {
+  constructor() {
+    super(...arguments);
+    c(this, "_state", {
+      connected: !1,
+      readyState: 0
+    });
+    c(this, "_options", {});
+    c(this, "_connectionUri", "");
+    c(this, "_mongoClient", null);
+    c(this, "_db", null);
+    c(this, "_models", /* @__PURE__ */ new Map());
+  }
+  get readyState() {
+    return this._state.readyState;
+  }
+  get host() {
+    return this._state.host;
+  }
+  get port() {
+    return this._state.port;
+  }
+  get name() {
+    return this._state.name;
+  }
+  get db() {
+    return this._db;
+  }
+  get client() {
+    return this._mongoClient;
+  }
+  get models() {
+    return this._models;
+  }
+  get uri() {
+    return this._connectionUri;
+  }
+  async connect(t, n) {
+    if (this._state.readyState === 1)
+      return console.warn("[Harbor] Already connected to MongoDB"), this;
+    this._connectionUri = t, this._options = {
+      maxPoolSize: 10,
+      minPoolSize: 1,
+      serverSelectionTimeoutMS: 3e4,
+      socketTimeoutMS: 45e3,
+      retryWrites: !0,
+      w: "majority",
+      ...n
+    }, this._state.readyState = 2, this.emit("connecting");
+    try {
+      const { MongoClient: s } = await import("mongodb");
+      this._mongoClient = new s(t, this._options), await this._mongoClient.connect();
+      const o = new URL(t), i = o.pathname.slice(1) || "test";
+      return this._db = this._mongoClient.db(i), this._state = {
+        connected: !0,
+        readyState: 1,
+        host: o.hostname,
+        port: parseInt(o.port) || 27017,
+        name: i
+      }, this.emit("connected"), this.emit("open"), console.log(`[Harbor] ${C("database.connected", { uri: `${o.hostname}:${o.port}/${i}` })}`), this;
+    } catch (s) {
+      throw this._state.readyState = 0, this.emit("error", s), s;
+    }
+  }
+  async disconnect() {
+    if (this._state.readyState === 0) {
+      console.warn("[Harbor] Already disconnected from MongoDB");
+      return;
+    }
+    this._state.readyState = 3, this.emit("disconnecting");
+    try {
+      this._mongoClient && await this._mongoClient.close(), this._state = {
+        connected: !1,
+        readyState: 0
+      }, this._mongoClient = null, this._db = null, this.emit("disconnected"), this.emit("close"), console.log(`[Harbor] ${C("database.disconnected")}`);
+    } catch (t) {
+      throw this.emit("error", t), t;
+    }
+  }
+  async close() {
+    return this.disconnect();
+  }
+  async ping() {
+    if (!this._db)
+      return !1;
+    try {
+      return await this._db.command({ ping: 1 }), !0;
+    } catch {
+      return !1;
+    }
+  }
+  collection(t) {
+    if (!this._db)
+      throw new Error("[Harbor] Not connected to database");
+    return this._db.collection(t);
+  }
+  async createCollection(t, n) {
+    if (!this._db)
+      throw new Error("[Harbor] Not connected to database");
+    return this._db.createCollection(t, n);
+  }
+  async dropCollection(t) {
+    if (!this._db)
+      throw new Error("[Harbor] Not connected to database");
+    return this._db.dropCollection(t);
+  }
+  async listCollections() {
+    if (!this._db)
+      throw new Error("[Harbor] Not connected to database");
+    return (await this._db.listCollections().toArray()).map((n) => n.name);
+  }
+  async dropDatabase() {
+    if (!this._db)
+      throw new Error("[Harbor] Not connected to database");
+    return this._db.dropDatabase();
+  }
+  // Transaction support
+  async startSession() {
+    if (!this._mongoClient)
+      throw new Error("[Harbor] Not connected to database");
+    return this._mongoClient.startSession();
+  }
+  async withTransaction(t, n) {
+    const s = await this.startSession();
+    try {
+      let o;
+      return await s.withTransaction(async () => {
+        o = await t(s);
+      }, n), o;
+    } finally {
+      await s.endSession();
+    }
+  }
+  // Event handlers with proper typing
+  on(t, n) {
+    return super.on(t, n);
+  }
+  once(t, n) {
+    return super.once(t, n);
+  }
+}
+const j = new Ne();
+async function mt(r, e) {
+  return j.connect(r, e);
+}
+async function ft() {
+  return j.disconnect();
+}
+var Y;
+Y = Symbol.toStringTag;
+class H {
+  constructor(e, t, n, s) {
+    c(this, "_model");
+    c(this, "_operation");
+    c(this, "_filter", {});
+    c(this, "_projection", null);
+    c(this, "_options", {});
+    c(this, "_update", null);
+    c(this, "_currentPath", null);
+    c(this, Y, "Query");
+    this._model = e, this._operation = t, this._filter = n || {}, this._update = s || null;
+  }
+  select(e) {
+    if (typeof e == "string") {
+      this._projection = {};
+      for (const t of e.split(" "))
+        t.startsWith("-") ? this._projection[t.slice(1)] = 0 : t && (this._projection[t] = 1);
+    } else
+      this._projection = e;
+    return this;
+  }
+  sort(e) {
+    if (typeof e == "string") {
+      const t = {};
+      for (const n of e.split(" "))
+        n.startsWith("-") ? t[n.slice(1)] = -1 : n && (t[n] = 1);
+      this._options.sort = t;
+    } else
+      this._options.sort = e;
+    return this;
+  }
+  limit(e) {
+    return this._options.limit = e, this;
+  }
+  skip(e) {
+    return this._options.skip = e, this;
+  }
+  lean() {
+    return this._options.lean = !0, this;
+  }
+  populate(e) {
+    return this._options.populate = e, this;
+  }
+  where(e, t) {
+    return this._currentPath = e, t !== void 0 && (this._filter[e] = t), this;
+  }
+  equals(e) {
+    return this._currentPath && (this._filter[this._currentPath] = e), this;
+  }
+  gt(e) {
+    return this._currentPath && (this._filter[this._currentPath] = { ...this._filter[this._currentPath], $gt: e }), this;
+  }
+  gte(e) {
+    return this._currentPath && (this._filter[this._currentPath] = { ...this._filter[this._currentPath], $gte: e }), this;
+  }
+  lt(e) {
+    return this._currentPath && (this._filter[this._currentPath] = { ...this._filter[this._currentPath], $lt: e }), this;
+  }
+  lte(e) {
+    return this._currentPath && (this._filter[this._currentPath] = { ...this._filter[this._currentPath], $lte: e }), this;
+  }
+  in(e) {
+    return this._currentPath && (this._filter[this._currentPath] = { $in: e }), this;
+  }
+  nin(e) {
+    return this._currentPath && (this._filter[this._currentPath] = { $nin: e }), this;
+  }
+  ne(e) {
+    return this._currentPath && (this._filter[this._currentPath] = { $ne: e }), this;
+  }
+  regex(e) {
+    return this._currentPath && (this._filter[this._currentPath] = { $regex: e }), this;
+  }
+  exists(e = !0) {
+    return this._currentPath && (this._filter[this._currentPath] = { $exists: e }), this;
+  }
+  or(e) {
+    return this._filter.$or = e, this;
+  }
+  and(e) {
+    return this._filter.$and = e, this;
+  }
+  nor(e) {
+    return this._filter.$nor = e, this;
+  }
+  async exec() {
+    const e = this._model.getCollection();
+    switch (this._operation) {
+      case "find": {
+        let t = e.find(this._filter, { projection: this._projection });
+        this._options.sort && (t = t.sort(this._options.sort)), this._options.skip && (t = t.skip(this._options.skip)), this._options.limit && (t = t.limit(this._options.limit));
+        const n = await t.toArray();
+        return this._options.lean ? n : n.map((s) => this._model.hydrate(s));
+      }
+      case "findOne": {
+        const t = await e.findOne(this._filter, { projection: this._projection });
+        return t ? this._options.lean ? t : this._model.hydrate(t) : null;
+      }
+      case "findOneAndUpdate": {
+        const t = await e.findOneAndUpdate(
+          this._filter,
+          this._update,
+          {
+            returnDocument: this._options.new ? "after" : "before",
+            upsert: this._options.upsert,
+            projection: this._projection
+          }
+        );
+        return t ? this._options.lean ? t : this._model.hydrate(t) : null;
+      }
+      case "findOneAndDelete": {
+        const t = await e.findOneAndDelete(this._filter, {
+          projection: this._projection
+        });
+        return t ? this._options.lean ? t : this._model.hydrate(t) : null;
+      }
+      default:
+        throw new Error(`Unknown operation: ${this._operation}`);
+    }
+  }
+  then(e, t) {
+    return this.exec().then(e, t);
+  }
+  catch(e) {
+    return this.exec().catch(e);
+  }
+  finally(e) {
+    return this.exec().finally(e);
+  }
+}
+class Q {
+  constructor(e, t) {
+    c(this, "_id");
+    c(this, "__v");
+    c(this, "isNew", !0);
+    c(this, "_model");
+    c(this, "_modified", /* @__PURE__ */ new Set());
+    /** Snapshot of document at load time for change tracking */
+    c(this, "_original", {});
+    var s;
+    if (this._model = e, this._id = ((s = t == null ? void 0 : t._id) == null ? void 0 : s.toString()) || new v().toString(), t) {
+      for (const [o, i] of Object.entries(t))
+        o === "_id" ? this._id = (i == null ? void 0 : i.toString()) || this._id : this[o] = i;
+      this._original = { ...t }, this.isNew = !1;
+    }
+    const n = e.schema;
+    for (const [o] of n.paths())
+      if (this[o] === void 0) {
+        const i = n.getDefault(o);
+        i !== void 0 && (this[o] = i);
+      }
+    for (const [o, i] of n.getVirtuals())
+      Object.defineProperty(this, o, {
+        get: i.get,
+        set: i.set,
+        enumerable: !0
+      });
+    for (const [o, i] of n.getMethods())
+      this[o] = i.bind(this);
+  }
+  /** Snapshot of document at load for change tracking */
+  get original() {
+    return this._original;
+  }
+  get id() {
+    return this._id;
+  }
+  isModified(e) {
+    return e ? this._modified.has(e) : this._modified.size > 0;
+  }
+  markModified(e) {
+    this._modified.add(e);
+  }
+  async save() {
+    var i;
+    const e = this._model.schema;
+    await this._model.runPreHooks("save", this);
+    const t = await e.validate(this.toObject());
+    if (!t.valid) {
+      const a = new Error(`Validation failed: ${(i = t.errors) == null ? void 0 : i.map((h) => h.message).join(", ")}`);
+      throw a.errors = t.errors, a;
+    }
+    const n = /* @__PURE__ */ new Date();
+    if (e.options.timestamps) {
+      const a = typeof e.options.timestamps == "object" && e.options.timestamps.createdAt || "createdAt", h = typeof e.options.timestamps == "object" && e.options.timestamps.updatedAt || "updatedAt";
+      this.isNew && a && (this[a] = n), this[h] = n;
+    }
+    const s = this._model.getCollection(), o = this.toObject();
+    if (this.isNew)
+      await s.insertOne({ _id: new v(this._id), ...o }), this.isNew = !1;
+    else {
+      if (e.options.versionKey) {
+        const a = typeof e.options.versionKey == "string" ? e.options.versionKey : "__v";
+        this[a] = (this[a] || 0) + 1;
+      }
+      await s.replaceOne({ _id: new v(this._id) }, o);
+    }
+    return this._original = { ...o }, this._modified.clear(), await this._model.runPostHooks("save", this), this;
+  }
+  async remove() {
+    return await this._model.runPreHooks("remove", this), await this._model.getCollection().deleteOne({ _id: new v(this._id) }), await this._model.runPostHooks("remove", this), this;
+  }
+  async deleteOne() {
+    await this._model.runPreHooks("deleteOne", this);
+    const t = await this._model.getCollection().deleteOne({ _id: new v(this._id) });
+    return await this._model.runPostHooks("deleteOne", this), {
+      acknowledged: t.acknowledged,
+      deletedCount: t.deletedCount
+    };
+  }
+  async updateOne(e) {
+    await this._model.runPreHooks("updateOne", this);
+    const n = await this._model.getCollection().updateOne({ _id: new v(this._id) }, e);
+    return await this._model.runPostHooks("updateOne", this), {
+      acknowledged: n.acknowledged,
+      modifiedCount: n.modifiedCount,
+      matchedCount: n.matchedCount
+    };
+  }
+  async populate(e) {
+    return this;
+  }
+  toObject() {
+    const e = { _id: this._id }, t = this._model.schema;
+    for (const [n] of t.paths())
+      n !== "_id" && this[n] !== void 0 && (e[n] = this[n]);
+    return e;
+  }
+  toJSON() {
+    return this.toObject();
+  }
+}
+const U = class U {
+  constructor(e, t, n) {
+    c(this, "_name");
+    c(this, "_schema");
+    c(this, "_collectionName");
+    this._name = e, this._schema = t, this._collectionName = n || e.toLowerCase() + "s";
+    for (const [s, o] of t.getStatics())
+      this[s] = o.bind(this);
+    U.models.set(e, this);
+  }
+  get modelName() {
+    return this._name;
+  }
+  get schema() {
+    return this._schema;
+  }
+  get collection() {
+    return { name: this._collectionName };
+  }
+  getCollection() {
+    if (!j.db)
+      throw new Error("[Harbor] Not connected to database. Call harbor.connect() first.");
+    return j.db.collection(this._collectionName);
+  }
+  // Create a new document instance
+  new(e) {
+    return new Q(this, e);
+  }
+  // Hydrate a plain object into a document
+  hydrate(e) {
+    const t = new Q(this, e);
+    return t.isNew = !1, t;
+  }
+  // Query methods
+  find(e, t, n) {
+    const s = new H(this, "find", e);
+    return t && s.select(t), n != null && n.sort && s.sort(n.sort), n != null && n.limit && s.limit(n.limit), n != null && n.skip && s.skip(n.skip), n != null && n.lean && s.lean(), s;
+  }
+  findOne(e, t, n) {
+    const s = new H(this, "findOne", e);
+    return t && s.select(t), n != null && n.lean && s.lean(), s;
+  }
+  findById(e, t, n) {
+    return this.findOne({ _id: new v(e) }, t, n);
+  }
+  // Create methods
+  async create(e) {
+    if (Array.isArray(e)) {
+      const n = [];
+      for (const s of e) {
+        const o = this.new(s);
+        await o.save(), n.push(o);
+      }
+      return n;
+    }
+    const t = this.new(e);
+    return await t.save(), t;
+  }
+  async insertMany(e, t) {
+    const n = this.getCollection(), s = e.map((i) => ({ _id: new v(), ...i })), o = await n.insertMany(s, { ordered: (t == null ? void 0 : t.ordered) ?? !0 });
+    return {
+      insertedCount: o.insertedCount,
+      insertedIds: Object.values(o.insertedIds).map((i) => i.toString())
+    };
+  }
+  // Update methods
+  async updateOne(e, t, n) {
+    var a;
+    await this.runPreHooks("updateOne", null);
+    const s = this.getCollection(), o = t.$set || t.$unset || t.$inc ? t : { $set: t }, i = await s.updateOne(e, o, { upsert: n == null ? void 0 : n.upsert });
+    return await this.runPostHooks("updateOne", null), {
+      acknowledged: i.acknowledged,
+      modifiedCount: i.modifiedCount,
+      matchedCount: i.matchedCount,
+      upsertedCount: i.upsertedCount,
+      upsertedId: (a = i.upsertedId) == null ? void 0 : a.toString()
+    };
+  }
+  async updateMany(e, t, n) {
+    await this.runPreHooks("updateMany", null);
+    const s = this.getCollection(), o = t.$set || t.$unset || t.$inc ? t : { $set: t }, i = await s.updateMany(e, o, { upsert: n == null ? void 0 : n.upsert });
+    return await this.runPostHooks("updateMany", null), {
+      acknowledged: i.acknowledged,
+      modifiedCount: i.modifiedCount,
+      matchedCount: i.matchedCount
+    };
+  }
+  findOneAndUpdate(e, t, n) {
+    const s = new H(this, "findOneAndUpdate", e, t);
+    return n != null && n.new && (s._options.new = !0), n != null && n.upsert && (s._options.upsert = !0), n != null && n.lean && s.lean(), s;
+  }
+  findByIdAndUpdate(e, t, n) {
+    return this.findOneAndUpdate({ _id: new v(e) }, t, n);
+  }
+  async replaceOne(e, t, n) {
+    const o = await this.getCollection().replaceOne(e, t, { upsert: n == null ? void 0 : n.upsert });
+    return {
+      acknowledged: o.acknowledged,
+      modifiedCount: o.modifiedCount,
+      matchedCount: o.matchedCount
+    };
+  }
+  // Delete methods
+  async deleteOne(e) {
+    await this.runPreHooks("deleteOne", null);
+    const n = await this.getCollection().deleteOne(e);
+    return await this.runPostHooks("deleteOne", null), {
+      acknowledged: n.acknowledged,
+      deletedCount: n.deletedCount
+    };
+  }
+  async deleteMany(e) {
+    await this.runPreHooks("deleteMany", null);
+    const n = await this.getCollection().deleteMany(e);
+    return await this.runPostHooks("deleteMany", null), {
+      acknowledged: n.acknowledged,
+      deletedCount: n.deletedCount
+    };
+  }
+  findOneAndDelete(e, t) {
+    const n = new H(this, "findOneAndDelete", e);
+    return t != null && t.lean && n.lean(), n;
+  }
+  findByIdAndDelete(e, t) {
+    return this.findOneAndDelete({ _id: new v(e) }, t);
+  }
+  // Count methods
+  async countDocuments(e) {
+    return this.getCollection().countDocuments(e || {});
+  }
+  async estimatedDocumentCount() {
+    return this.getCollection().estimatedDocumentCount();
+  }
+  // Aggregate
+  async aggregate(e, t) {
+    return this.getCollection().aggregate(e, t).toArray();
+  }
+  // Distinct
+  async distinct(e, t) {
+    return this.getCollection().distinct(e, t || {});
+  }
+  // Exists
+  async exists(e) {
+    const t = await this.findOne(e).select({ _id: 1 }).lean();
+    return t ? { _id: t._id.toString() } : null;
+  }
+  // Bulk operations
+  async bulkWrite(e) {
+    const n = await this.getCollection().bulkWrite(e);
+    return {
+      ok: n.ok,
+      insertedCount: n.insertedCount,
+      matchedCount: n.matchedCount,
+      modifiedCount: n.modifiedCount,
+      deletedCount: n.deletedCount,
+      upsertedCount: n.upsertedCount,
+      insertedIds: n.insertedIds || {},
+      upsertedIds: n.upsertedIds || {}
+    };
+  }
+  // Index methods
+  async createIndex(e, t) {
+    return this.getCollection().createIndex(e, t);
+  }
+  async createIndexes(e) {
+    const t = this.getCollection(), n = e.map((s) => ({ key: s.fields, ...s.options }));
+    return t.createIndexes(n);
+  }
+  async listIndexes() {
+    return this.getCollection().listIndexes().toArray();
+  }
+  async dropIndex(e) {
+    await this.getCollection().dropIndex(e);
+  }
+  // Populate
+  async populate(e, t) {
+    return e;
+  }
+  // Watch (change streams)
+  watch(e, t) {
+    return this.getCollection().watch(e, t);
+  }
+  // Hook execution
+  async runPreHooks(e, t) {
+    const n = this._schema.getPreHooks().get(e) || [];
+    for (const s of n)
+      await new Promise((o, i) => {
+        try {
+          const a = s.call(t, o);
+          a instanceof Promise && a.then(o).catch(i);
+        } catch (a) {
+          i(a);
+        }
+      });
+  }
+  async runPostHooks(e, t) {
+    const n = this._schema.getPostHooks().get(e) || [];
+    for (const s of n)
+      await new Promise((o, i) => {
+        try {
+          const a = s.call(t, o);
+          a instanceof Promise && a.then(o).catch(i);
+        } catch (a) {
+          i(a);
+        }
+      });
+  }
+};
+c(U, "models", /* @__PURE__ */ new Map());
+let L = U;
+function gt(r, e, t) {
+  const n = L.models.get(r);
+  return n || new L(r, e, t);
+}
+const pt = {
+  ObjectId: v
+}, k = A("changelog"), Ie = {
+  filePath: "./CHANGELOG.md",
+  format: "markdown",
+  includeUnreleased: !0
+};
+function xe(r = {}) {
+  const e = { ...Ie, ...r }, t = [];
+  let n = [];
+  function s() {
+    const d = R(process.cwd(), e.filePath);
+    if (!I(d)) {
+      k.info("No changelog file found, starting fresh");
+      return;
+    }
+    try {
+      const l = X(d, "utf-8");
+      o(l), k.info("Changelog loaded", { entries: t.length });
+    } catch (l) {
+      k.error("Failed to load changelog", l);
+    }
+  }
+  function o(d) {
+    const l = /## \[(\d+\.\d+\.\d+(?:-[\w.]+)?)\](?: - (\d{4}-\d{2}-\d{2}))?/g, u = d.split(l);
+    for (let f = 1; f < u.length; f += 3) {
+      const m = u[f], T = u[f + 1], y = u[f + 2];
+      if (m && y) {
+        const $ = {
+          version: m,
+          date: T ? new Date(T) : /* @__PURE__ */ new Date(),
+          changes: i(y)
+        };
+        t.push($);
+      }
+    }
+  }
+  function i(d) {
+    const l = [], u = d.split(`
+`);
+    let f = null;
+    for (const m of u) {
+      const T = m.match(/^### (Added|Changed|Deprecated|Removed|Fixed|Security)/i);
+      if (T) {
+        f = T[1].toLowerCase();
+        continue;
+      }
+      const y = m.match(/^- (.+)/);
+      y && f && l.push({
+        type: f,
+        description: y[1].trim()
+      });
+    }
+    return l;
+  }
+  function a() {
+    const d = R(process.cwd(), e.filePath), l = h();
+    se(d, l, "utf-8"), k.info("Changelog saved", { path: d });
+  }
+  function h() {
+    let d = `# Changelog
+
+`;
+    d += `All notable changes to this project will be documented in this file.
+
+`, d += `The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+`, d += `and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+`, e.includeUnreleased && n.length > 0 && (d += `## [Unreleased]
+
+`, d += g(n), d += `
+`);
+    for (const l of t) {
+      const u = l.date.toISOString().split("T")[0];
+      if (d += `## [${l.version}] - ${u}
+
+`, d += g(l.changes), l.breaking && l.breaking.length > 0) {
+        d += `### BREAKING CHANGES
+
+`;
+        for (const f of l.breaking)
+          d += `- ${f.description}
+`;
+        d += `
+`;
+      }
+      d += `
+`;
+    }
+    return d;
+  }
+  function g(d) {
+    const l = w(d);
+    let u = "";
+    const f = ["added", "changed", "deprecated", "removed", "fixed", "security"];
+    for (const m of f) {
+      const T = l[m];
+      if (T && T.length > 0) {
+        u += `### ${b(m)}
+
+`;
+        for (const y of T) {
+          let $ = `- ${y.description}`;
+          y.scope && ($ = `- **${y.scope}:** ${y.description}`), y.issue && ($ += ` (#${y.issue})`), u += $ + `
+`;
+        }
+        u += `
+`;
+      }
+    }
+    return u;
+  }
+  function w(d) {
+    const l = {
+      added: [],
+      changed: [],
+      deprecated: [],
+      removed: [],
+      fixed: [],
+      security: []
+    };
+    for (const u of d)
+      l[u.type].push(u);
+    return l;
+  }
+  function b(d) {
+    return d.charAt(0).toUpperCase() + d.slice(1);
+  }
+  return {
+    load: s,
+    save: a,
+    addChange(d, l, u) {
+      n.push({
+        type: d,
+        description: l,
+        scope: u == null ? void 0 : u.scope,
+        issue: u == null ? void 0 : u.issue
+      });
+    },
+    release(d) {
+      const l = {
+        version: d,
+        date: /* @__PURE__ */ new Date(),
+        changes: [...n]
+      };
+      return t.unshift(l), n = [], a(), k.info(`Released version ${d}`), l;
+    },
+    getEntries() {
+      return [...t];
+    },
+    getUnreleased() {
+      return [...n];
+    },
+    getLatestVersion() {
+      var d;
+      return ((d = t[0]) == null ? void 0 : d.version) ?? null;
+    },
+    getReleaseNotes(d) {
+      var f;
+      const l = t.find((m) => m.version === d);
+      if (!l) return null;
+      const u = w(l.changes);
+      return {
+        version: l.version,
+        date: l.date,
+        added: u.added.map((m) => m.description),
+        changed: u.changed.map((m) => m.description),
+        deprecated: u.deprecated.map((m) => m.description),
+        removed: u.removed.map((m) => m.description),
+        fixed: u.fixed.map((m) => m.description),
+        security: u.security.map((m) => m.description),
+        breaking: ((f = l.breaking) == null ? void 0 : f.map((m) => m.description)) ?? []
+      };
+    }
+  };
+}
+class _t {
+  constructor(e) {
+    c(this, "manager");
+    c(this, "load", () => this.manager.load());
+    c(this, "save", () => this.manager.save());
+    c(this, "addChange", (...e) => this.manager.addChange(...e));
+    c(this, "release", (e) => this.manager.release(e));
+    c(this, "getEntries", () => this.manager.getEntries());
+    c(this, "getUnreleased", () => this.manager.getUnreleased());
+    c(this, "getLatestVersion", () => this.manager.getLatestVersion());
+    c(this, "getReleaseNotes", (e) => this.manager.getReleaseNotes(e));
+    this.manager = xe(e);
+  }
+}
+class De {
+  constructor(e = {}) {
+    this.options = e;
+  }
+  get config() {
+    return this.options;
+  }
+  generate() {
+    console.log("[Harbor] Portal generation is coming soon.");
+  }
+}
+function yt(r) {
+  return new De(r);
+}
+function wt() {
+  console.log("[Harbor] API documentation generation is coming soon.");
+}
+function W(r) {
+  return typeof r == "object" && r !== null && !Array.isArray(r);
+}
+function Me(r, e) {
+  const t = { ...r };
+  for (const n in e)
+    if (Object.prototype.hasOwnProperty.call(e, n)) {
+      const s = e[n], o = r[n];
+      W(s) && W(o) ? t[n] = Me(
+        o,
+        s
+      ) : s !== void 0 && (t[n] = s);
+    }
+  return t;
+}
+function vt(r, e) {
+  const t = {};
+  for (const n of e)
+    Object.prototype.hasOwnProperty.call(r, n) && (t[n] = r[n]);
+  return t;
+}
+function bt(r, e) {
+  const t = { ...r };
+  for (const n of e)
+    delete t[n];
+  return t;
+}
+function Ct(r = 16) {
+  const e = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+  let t = "";
+  for (let n = 0; n < r; n++)
+    t += e.charAt(Math.floor(Math.random() * e.length));
+  return t;
+}
+function Tt(r, e = "ISO") {
+  if (e === "ISO")
+    return r.toISOString();
+  const t = r.getFullYear(), n = String(r.getMonth() + 1).padStart(2, "0"), s = String(r.getDate()).padStart(2, "0"), o = String(r.getHours()).padStart(2, "0"), i = String(r.getMinutes()).padStart(2, "0"), a = String(r.getSeconds()).padStart(2, "0");
+  switch (e) {
+    case "DATE":
+      return `${t}-${n}-${s}`;
+    case "TIME":
+      return `${o}:${i}:${a}`;
+    case "DATETIME":
+      return `${t}-${n}-${s} ${o}:${i}:${a}`;
+    default:
+      return r.toISOString();
+  }
+}
+function Ot(r) {
+  return new Promise((e) => setTimeout(e, r));
+}
+const N = A("http"), _ = {
+  info: "\x1B[36m",
+  // Cyan for 1xx
+  success: "\x1B[32m",
+  // Green for 2xx
+  redirect: "\x1B[36m",
+  // Cyan for 3xx
+  clientError: "\x1B[33m",
+  // Yellow for 4xx
+  serverError: "\x1B[31m",
+  // Red for 5xx
+  reset: "\x1B[0m"
+};
+function je(r) {
+  return r >= 500 ? _.serverError : r >= 400 ? _.clientError : r >= 300 ? _.redirect : r >= 200 ? _.success : _.info;
+}
+function G(r) {
+  return {
+    GET: "\x1B[32m",
+    // Green
+    POST: "\x1B[34m",
+    // Blue
+    PUT: "\x1B[33m",
+    // Yellow
+    PATCH: "\x1B[35m",
+    // Magenta
+    DELETE: "\x1B[31m",
+    // Red
+    OPTIONS: "\x1B[36m",
+    // Cyan
+    HEAD: "\x1B[36m"
+    // Cyan
+  }[r] ?? "\x1B[0m";
+}
+function Le(r) {
+  return r === 0 ? "-" : r < 1024 ? `${r}B` : r < 1024 * 1024 ? `${(r / 1024).toFixed(1)}KB` : `${(r / (1024 * 1024)).toFixed(1)}MB`;
+}
+function Ue(r, e, t) {
+  const n = Date.now() - t, s = e.statusCode, o = e.get("content-length") ?? "0";
+  return {
+    method: r.method,
+    url: r.originalUrl || r.url,
+    status: s,
+    statusColor: je(s),
+    responseTime: n,
+    contentLength: Le(parseInt(o, 10) || 0),
+    remoteAddr: r.ip || r.socket.remoteAddress || "-",
+    date: (/* @__PURE__ */ new Date()).toISOString(),
+    httpVersion: `HTTP/${r.httpVersionMajor}.${r.httpVersionMinor}`,
+    userAgent: r.get("user-agent") ?? "-",
+    referrer: r.get("referrer") ?? "-"
+  };
+}
+const Fe = {
+  tiny: (r, e) => {
+    const t = e ? `${G(r.method)}${r.method}${_.reset}` : r.method, n = e ? `${r.statusColor}${r.status}${_.reset}` : String(r.status);
+    return `${t} ${r.url} ${n} ${r.responseTime}ms`;
+  },
+  short: (r, e) => {
+    const t = e ? `${G(r.method)}${r.method}${_.reset}` : r.method, n = e ? `${r.statusColor}${r.status}${_.reset}` : String(r.status);
+    return `${r.remoteAddr} ${t} ${r.url} ${n} ${r.responseTime}ms - ${r.contentLength}`;
+  },
+  dev: (r, e) => {
+    const t = e ? `${G(r.method)}${r.method.padEnd(7)}${_.reset}` : r.method.padEnd(7), n = e ? `${r.statusColor}${r.status}${_.reset}` : String(r.status), s = r.responseTime < 100 ? `${r.responseTime}ms` : r.responseTime < 1e3 ? `\x1B[33m${r.responseTime}ms${_.reset}` : `\x1B[31m${r.responseTime}ms${_.reset}`;
+    return `${t} ${r.url} ${n} ${e ? s : `${r.responseTime}ms`} - ${r.contentLength}`;
+  },
+  combined: (r) => `${r.remoteAddr} - - [${r.date}] "${r.method} ${r.url} ${r.httpVersion}" ${r.status} ${r.contentLength} "${r.referrer}" "${r.userAgent}"`,
+  common: (r) => `${r.remoteAddr} - - [${r.date}] "${r.method} ${r.url} ${r.httpVersion}" ${r.status} ${r.contentLength}`,
+  custom: () => ""
+  // Handled separately
+};
+function Et(r = {}) {
+  const {
+    format: e = "dev",
+    skip: t,
+    immediate: n = !1,
+    customFormat: s,
+    colorize: o = !0
+  } = r;
+  return (i, a, h) => {
+    const g = Date.now();
+    n && N.info(C("http.requestStart", { method: i.method, url: i.url }));
+    const w = a.end;
+    a.end = function(b, d, l) {
+      a.end = w;
+      const u = a.end(b, d, l);
+      if (t && t(i, a))
+        return u;
+      const f = Ue(i, a, g);
+      let m;
+      return e === "custom" && s ? m = s(f) : m = Fe[e](f, o), f.status >= 500 ? N.error(m) : f.status >= 400 ? N.warn(m) : N.info(m), u;
+    }, h();
+  };
+}
+const St = {
+  /** Skip successful responses */
+  successOnly: (r, e) => e.statusCode < 400,
+  /** Skip health check endpoints */
+  healthChecks: (r) => r.url === "/health" || r.url === "/healthz" || r.url === "/ready",
+  /** Skip static files */
+  staticFiles: (r) => /\.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$/i.test(r.url),
+  /** Skip based on custom paths */
+  paths: (r) => (e) => r.some((t) => e.url.startsWith(t))
+};
+function At(r) {
+  return r;
+}
+export {
+  Je as CONTENT_TYPES,
+  _t as ChangelogManager,
+  lt as DELETE,
+  jt as DockerManager,
+  it as GET,
+  Ze as HEADERS,
+  Xe as HTTP_METHODS,
+  p as HTTP_STATUS,
+  Q as HarborDocument,
+  O as HarborError,
+  L as Model,
+  Ht as MongoValidator,
+  dt as PATCH,
+  at as POST,
+  ct as PUT,
+  De as PortalGenerator,
+  H as Query,
+  J as RouteBuilder,
+  Z as Schema,
+  pt as Types,
+  st as addTranslations,
+  mt as connect,
+  j as connection,
+  xe as createChangelogManager,
+  At as createCustomFormat,
+  Lt as createDockerManager,
+  Ee as createErrorHandler,
+  A as createLogger,
+  Nt as createMongoSchema,
+  It as createParamValidator,
+  yt as createPortal,
+  K as createRouter,
+  ht as createServer,
+  Me as deepMerge,
+  et as defineConfig,
+  ft as disconnect,
+  Tt as formatDate,
+  wt as generateDocs,
+  Ct as generateId,
+  rt as getAvailableLocales,
+  nt as getLocale,
+  Et as httpLogger,
+  me as loadConfig,
+  gt as model,
+  bt as omit,
+  vt as pick,
+  ot as registerLocale,
+  ut as route,
+  kt as setGlobalLogLevel,
+  tt as setLocale,
+  St as skipFunctions,
+  Ot as sleep,
+  C as t,
+  xt as validateField,
+  F as validateRequest,
+  Dt as validators
+};
+//# sourceMappingURL=index.es.js.map