@forgedevstack/harbor 1.0.0 → 1.5.0

package/dist/index-DIVHd6rO.mjs

@@ -0,0 +1,1054 @@
+import { EventEmitter as g } from "events";
+import { ObjectId as c } from "mongodb";
+const y = {
+  // 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"
+}, w = {
+  // 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": "טרנזקציה בוטלה"
+}, d = {
+  en: y,
+  he: w
+};
+let m = "en";
+function A(r) {
+  if (!d[r]) {
+    console.warn(`Locale "${r}" not found, falling back to "en"`), m = "en";
+    return;
+  }
+  m = r;
+}
+function H() {
+  return m;
+}
+function j() {
+  return Object.keys(d);
+}
+function f(r, t) {
+  let n = (d[m] ?? d.en)[r] ?? d.en[r] ?? r;
+  if (t)
+    for (const [i, s] of Object.entries(t))
+      n = n.replace(new RegExp(`{${i}}`, "g"), String(s ?? ""));
+  return n;
+}
+function M(r, t) {
+  d[r] || (d[r] = {}), Object.assign(d[r], t);
+}
+function $(r, t) {
+  d[r] = t;
+}
+class p {
+  _definition;
+  _options;
+  _paths = /* @__PURE__ */ new Map();
+  _virtuals = /* @__PURE__ */ new Map();
+  _methods = /* @__PURE__ */ new Map();
+  _statics = /* @__PURE__ */ new Map();
+  _preHooks = /* @__PURE__ */ new Map();
+  _postHooks = /* @__PURE__ */ new Map();
+  _indexes = [];
+  _plugins = [];
+  // Public accessors for methods and statics
+  methods = {};
+  statics = {};
+  virtuals = {};
+  constructor(t, e) {
+    if (this._definition = t, this._options = {
+      timestamps: !1,
+      strict: !0,
+      strictQuery: !1,
+      _id: !0,
+      id: !0,
+      versionKey: "__v",
+      autoIndex: !0,
+      autoCreate: !0,
+      minimize: !0,
+      ...e
+    }, this._parseDefinition(t), 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", i = 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 }), i && this._paths.set(i, { 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, i, s) => (this._methods.set(i, s), !0),
+      get: (n, i) => this._methods.get(i)
+    }), this.statics = new Proxy({}, {
+      set: (n, i, s) => (this._statics.set(i, s), !0),
+      get: (n, i) => this._statics.get(i)
+    });
+  }
+  _parseDefinition(t, e = "") {
+    for (const [n, i] of Object.entries(t)) {
+      const s = e ? `${e}.${n}` : n;
+      if (typeof i == "string")
+        this._paths.set(s, { type: i });
+      else if (typeof i == "object" && i !== null) {
+        const o = i;
+        "type" in o ? typeof o.type == "string" ? this._paths.set(s, o) : Array.isArray(o.type) ? this._paths.set(s, { ...o, type: "Array" }) : typeof o.type == "object" && (this._paths.set(s, { type: "Object" }), this._parseDefinition(o.type, s)) : (this._paths.set(s, { type: "Object" }), this._parseDefinition(i, s));
+      }
+    }
+  }
+  // Add additional fields to schema
+  add(t, e) {
+    return this._parseDefinition(t, e), this;
+  }
+  // Get path definition
+  path(t) {
+    return this._paths.get(t);
+  }
+  // Get all paths
+  paths() {
+    return this._paths;
+  }
+  // Define virtual field
+  virtual(t) {
+    return new b(this, t);
+  }
+  // Define instance method
+  method(t, e) {
+    return this._methods.set(t, e), this;
+  }
+  // Define static method
+  static(t, e) {
+    return this._statics.set(t, e), this;
+  }
+  // Pre hook
+  pre(t, e) {
+    const n = Array.isArray(t) ? t : [t];
+    for (const i of n) {
+      const s = this._preHooks.get(i) || [];
+      s.push(e), this._preHooks.set(i, s);
+    }
+    return this;
+  }
+  // Post hook
+  post(t, e) {
+    const n = Array.isArray(t) ? t : [t];
+    for (const i of n) {
+      const s = this._postHooks.get(i) || [];
+      s.push(e), this._postHooks.set(i, s);
+    }
+    return this;
+  }
+  // Define index
+  index(t, e) {
+    return this._indexes.push({ fields: t, options: e }), this;
+  }
+  // Plugin support
+  plugin(t, e) {
+    return this._plugins.push({ fn: t, options: e }), t(this, e), this;
+  }
+  // Load class methods as schema methods
+  loadClass(t) {
+    const e = t.prototype;
+    for (const n of Object.getOwnPropertyNames(e)) {
+      if (n === "constructor") continue;
+      const i = Object.getOwnPropertyDescriptor(e, n);
+      if (i?.get)
+        this._virtuals.set(n, { get: i.get });
+      else if (i?.set) {
+        const s = this._virtuals.get(n) || {};
+        this._virtuals.set(n, { ...s, set: i.set });
+      } else typeof i?.value == "function" && this._methods.set(n, i.value);
+    }
+    for (const n of Object.getOwnPropertyNames(t)) {
+      if (["length", "prototype", "name"].includes(n)) continue;
+      const i = t[n];
+      typeof i == "function" && this._statics.set(n, i);
+    }
+    return this;
+  }
+  // Clone schema
+  clone() {
+    const t = new p({}, this._options);
+    return t._paths = new Map(this._paths), t._virtuals = new Map(this._virtuals), t._methods = new Map(this._methods), t._statics = new Map(this._statics), t._preHooks = new Map(this._preHooks), t._postHooks = new Map(this._postHooks), t._indexes = [...this._indexes], t;
+  }
+  // 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(t) {
+    const e = [];
+    for (const [n, i] of this._paths) {
+      const s = this._getNestedValue(t, n), o = await this._validateField(n, s, i);
+      e.push(...o);
+    }
+    return e.length > 0 ? { valid: !1, errors: e } : { valid: !0 };
+  }
+  _getNestedValue(t, e) {
+    return e.split(".").reduce((n, i) => n?.[i], t);
+  }
+  async _validateField(t, e, n) {
+    const i = [];
+    return n.required && e == null ? (i.push({ path: t, message: `${t} is required` }), i) : e == null ? i : this._validateType(e, n.type) ? (n.type === "String" && typeof e == "string" && (n.minLength && e.length < n.minLength && i.push({ path: t, message: `${t} must be at least ${n.minLength} characters` }), n.maxLength && e.length > n.maxLength && i.push({ path: t, message: `${t} must be at most ${n.maxLength} characters` }), n.match && !n.match.test(e) && i.push({ path: t, message: `${t} does not match required pattern` }), n.enum && !n.enum.includes(e) && i.push({ path: t, message: `${t} must be one of: ${n.enum.join(", ")}` })), n.type === "Number" && typeof e == "number" && (n.min !== void 0 && e < n.min && i.push({ path: t, message: `${t} must be at least ${n.min}` }), n.max !== void 0 && e > n.max && i.push({ path: t, message: `${t} must be at most ${n.max}` })), n.validate && (await n.validate.validator(e) || i.push({ path: t, message: n.validate.message || `${t} failed validation` })), i) : (i.push({ path: t, message: `${t} must be of type ${n.type}` }), i);
+  }
+  _validateType(t, e) {
+    switch (e) {
+      case "String":
+        return typeof t == "string";
+      case "Number":
+        return typeof t == "number" && !isNaN(t);
+      case "Boolean":
+        return typeof t == "boolean";
+      case "Date":
+        return t instanceof Date || typeof t == "string" && !isNaN(Date.parse(t));
+      case "ObjectId":
+        return typeof t == "string" && /^[0-9a-fA-F]{24}$/.test(t);
+      case "Array":
+        return Array.isArray(t);
+      case "Object":
+      case "Mixed":
+        return typeof t == "object" && t !== null;
+      case "Buffer":
+        return Buffer.isBuffer(t);
+      default:
+        return !0;
+    }
+  }
+  // Apply transformations (lowercase, uppercase, trim)
+  transformValue(t, e) {
+    const n = this._paths.get(t);
+    if (!n || typeof e != "string") return e;
+    let i = e;
+    return n.lowercase && (i = i.toLowerCase()), n.uppercase && (i = i.toUpperCase()), n.trim && (i = i.trim()), i;
+  }
+  // Get default value for a field
+  getDefault(t) {
+    const e = this._paths.get(t);
+    if (!(!e || e.default === void 0))
+      return typeof e.default == "function" ? e.default() : e.default;
+  }
+}
+class b {
+  schema;
+  name;
+  constructor(t, e) {
+    this.schema = t, this.name = e;
+  }
+  get(t) {
+    const e = this.schema.getVirtuals(), n = e.get(this.name) || {};
+    return e.set(this.name, { ...n, get: t }), this;
+  }
+  set(t) {
+    const e = this.schema.getVirtuals(), n = e.get(this.name) || {};
+    return e.set(this.name, { ...n, set: t }), this;
+  }
+}
+class v extends g {
+  _state = {
+    connected: !1,
+    readyState: 0
+  };
+  // @ts-ignore - Reserved for future use
+  _uri = "";
+  _options = {};
+  _mongoClient = null;
+  _db = null;
+  _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;
+  }
+  async connect(t, e) {
+    if (this._state.readyState === 1)
+      return console.warn("[Harbor] Already connected to MongoDB"), this;
+    this._uri = t, this._options = {
+      maxPoolSize: 10,
+      minPoolSize: 1,
+      serverSelectionTimeoutMS: 3e4,
+      socketTimeoutMS: 45e3,
+      retryWrites: !0,
+      w: "majority",
+      ...e
+    }, this._state.readyState = 2, this.emit("connecting");
+    try {
+      const { MongoClient: n } = await import("mongodb");
+      this._mongoClient = new n(t, this._options), await this._mongoClient.connect();
+      const i = new URL(t), s = i.pathname.slice(1) || "test";
+      return this._db = this._mongoClient.db(s), this._state = {
+        connected: !0,
+        readyState: 1,
+        host: i.hostname,
+        port: parseInt(i.port) || 27017,
+        name: s
+      }, this.emit("connected"), this.emit("open"), console.log(`[Harbor] ${f("database.connected", { uri: `${i.hostname}:${i.port}/${s}` })}`), this;
+    } catch (n) {
+      throw this._state.readyState = 0, this.emit("error", n), n;
+    }
+  }
+  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] ${f("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, e) {
+    if (!this._db)
+      throw new Error("[Harbor] Not connected to database");
+    return this._db.createCollection(t, e);
+  }
+  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((e) => e.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, e) {
+    const n = await this.startSession();
+    try {
+      let i;
+      return await n.withTransaction(async () => {
+        i = await t(n);
+      }, e), i;
+    } finally {
+      await n.endSession();
+    }
+  }
+  // Event handlers with proper typing
+  on(t, e) {
+    return super.on(t, e);
+  }
+  once(t, e) {
+    return super.once(t, e);
+  }
+}
+const h = new v();
+async function C(r, t) {
+  return h.connect(r, t);
+}
+async function k() {
+  return h.disconnect();
+}
+class u {
+  _model;
+  _operation;
+  _filter = {};
+  _projection = null;
+  _options = {};
+  _update = null;
+  _currentPath = null;
+  constructor(t, e, n, i) {
+    this._model = t, this._operation = e, this._filter = n || {}, this._update = i || null;
+  }
+  select(t) {
+    if (typeof t == "string") {
+      this._projection = {};
+      for (const e of t.split(" "))
+        e.startsWith("-") ? this._projection[e.slice(1)] = 0 : e && (this._projection[e] = 1);
+    } else
+      this._projection = t;
+    return this;
+  }
+  sort(t) {
+    if (typeof t == "string") {
+      const e = {};
+      for (const n of t.split(" "))
+        n.startsWith("-") ? e[n.slice(1)] = -1 : n && (e[n] = 1);
+      this._options.sort = e;
+    } else
+      this._options.sort = t;
+    return this;
+  }
+  limit(t) {
+    return this._options.limit = t, this;
+  }
+  skip(t) {
+    return this._options.skip = t, this;
+  }
+  lean() {
+    return this._options.lean = !0, this;
+  }
+  populate(t) {
+    return this._options.populate = t, this;
+  }
+  where(t, e) {
+    return this._currentPath = t, e !== void 0 && (this._filter[t] = e), this;
+  }
+  equals(t) {
+    return this._currentPath && (this._filter[this._currentPath] = t), this;
+  }
+  gt(t) {
+    return this._currentPath && (this._filter[this._currentPath] = { ...this._filter[this._currentPath], $gt: t }), this;
+  }
+  gte(t) {
+    return this._currentPath && (this._filter[this._currentPath] = { ...this._filter[this._currentPath], $gte: t }), this;
+  }
+  lt(t) {
+    return this._currentPath && (this._filter[this._currentPath] = { ...this._filter[this._currentPath], $lt: t }), this;
+  }
+  lte(t) {
+    return this._currentPath && (this._filter[this._currentPath] = { ...this._filter[this._currentPath], $lte: t }), this;
+  }
+  in(t) {
+    return this._currentPath && (this._filter[this._currentPath] = { $in: t }), this;
+  }
+  nin(t) {
+    return this._currentPath && (this._filter[this._currentPath] = { $nin: t }), this;
+  }
+  ne(t) {
+    return this._currentPath && (this._filter[this._currentPath] = { $ne: t }), this;
+  }
+  regex(t) {
+    return this._currentPath && (this._filter[this._currentPath] = { $regex: t }), this;
+  }
+  exists(t = !0) {
+    return this._currentPath && (this._filter[this._currentPath] = { $exists: t }), this;
+  }
+  or(t) {
+    return this._filter.$or = t, this;
+  }
+  and(t) {
+    return this._filter.$and = t, this;
+  }
+  nor(t) {
+    return this._filter.$nor = t, this;
+  }
+  async exec() {
+    const t = this._model.getCollection();
+    switch (this._operation) {
+      case "find": {
+        let e = t.find(this._filter, { projection: this._projection });
+        this._options.sort && (e = e.sort(this._options.sort)), this._options.skip && (e = e.skip(this._options.skip)), this._options.limit && (e = e.limit(this._options.limit));
+        const n = await e.toArray();
+        return this._options.lean ? n : n.map((i) => this._model.hydrate(i));
+      }
+      case "findOne": {
+        const e = await t.findOne(this._filter, { projection: this._projection });
+        return e ? this._options.lean ? e : this._model.hydrate(e) : null;
+      }
+      case "findOneAndUpdate": {
+        const e = await t.findOneAndUpdate(
+          this._filter,
+          this._update,
+          {
+            returnDocument: this._options.new ? "after" : "before",
+            upsert: this._options.upsert,
+            projection: this._projection
+          }
+        );
+        return e ? this._options.lean ? e : this._model.hydrate(e) : null;
+      }
+      case "findOneAndDelete": {
+        const e = await t.findOneAndDelete(this._filter, {
+          projection: this._projection
+        });
+        return e ? this._options.lean ? e : this._model.hydrate(e) : null;
+      }
+      default:
+        throw new Error(`Unknown operation: ${this._operation}`);
+    }
+  }
+  then(t, e) {
+    return this.exec().then(t, e);
+  }
+  catch(t) {
+    return this.exec().catch(t);
+  }
+  finally(t) {
+    return this.exec().finally(t);
+  }
+  [Symbol.toStringTag] = "Query";
+}
+class _ {
+  _id;
+  __v;
+  isNew = !0;
+  _model;
+  // @ts-ignore - Reserved for tracking changes
+  _original = {};
+  _modified = /* @__PURE__ */ new Set();
+  constructor(t, e) {
+    if (this._model = t, this._id = e?._id?.toString() || new c().toString(), e) {
+      for (const [i, s] of Object.entries(e))
+        i === "_id" ? this._id = s?.toString() || this._id : this[i] = s;
+      this._original = { ...e }, this.isNew = !1;
+    }
+    const n = t.schema;
+    for (const [i] of n.paths())
+      if (this[i] === void 0) {
+        const s = n.getDefault(i);
+        s !== void 0 && (this[i] = s);
+      }
+    for (const [i, s] of n.getVirtuals())
+      Object.defineProperty(this, i, {
+        get: s.get,
+        set: s.set,
+        enumerable: !0
+      });
+    for (const [i, s] of n.getMethods())
+      this[i] = s.bind(this);
+  }
+  get id() {
+    return this._id;
+  }
+  isModified(t) {
+    return t ? this._modified.has(t) : this._modified.size > 0;
+  }
+  markModified(t) {
+    this._modified.add(t);
+  }
+  async save() {
+    const t = this._model.schema;
+    await this._model.runPreHooks("save", this);
+    const e = await t.validate(this.toObject());
+    if (!e.valid) {
+      const o = new Error(`Validation failed: ${e.errors?.map((a) => a.message).join(", ")}`);
+      throw o.errors = e.errors, o;
+    }
+    const n = /* @__PURE__ */ new Date();
+    if (t.options.timestamps) {
+      const o = typeof t.options.timestamps == "object" && t.options.timestamps.createdAt || "createdAt", a = typeof t.options.timestamps == "object" && t.options.timestamps.updatedAt || "updatedAt";
+      this.isNew && o && (this[o] = n), this[a] = n;
+    }
+    const i = this._model.getCollection(), s = this.toObject();
+    if (this.isNew)
+      await i.insertOne({ _id: new c(this._id), ...s }), this.isNew = !1;
+    else {
+      if (t.options.versionKey) {
+        const o = typeof t.options.versionKey == "string" ? t.options.versionKey : "__v";
+        this[o] = (this[o] || 0) + 1;
+      }
+      await i.replaceOne({ _id: new c(this._id) }, s);
+    }
+    return this._original = { ...s }, 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 c(this._id) }), await this._model.runPostHooks("remove", this), this;
+  }
+  async deleteOne() {
+    await this._model.runPreHooks("deleteOne", this);
+    const e = await this._model.getCollection().deleteOne({ _id: new c(this._id) });
+    return await this._model.runPostHooks("deleteOne", this), {
+      acknowledged: e.acknowledged,
+      deletedCount: e.deletedCount
+    };
+  }
+  async updateOne(t) {
+    await this._model.runPreHooks("updateOne", this);
+    const n = await this._model.getCollection().updateOne({ _id: new c(this._id) }, t);
+    return await this._model.runPostHooks("updateOne", this), {
+      acknowledged: n.acknowledged,
+      modifiedCount: n.modifiedCount,
+      matchedCount: n.matchedCount
+    };
+  }
+  async populate(t) {
+    return this;
+  }
+  toObject() {
+    const t = { _id: this._id }, e = this._model.schema;
+    for (const [n] of e.paths())
+      n !== "_id" && this[n] !== void 0 && (t[n] = this[n]);
+    return t;
+  }
+  toJSON() {
+    return this.toObject();
+  }
+}
+class l {
+  _name;
+  _schema;
+  _collectionName;
+  static models = /* @__PURE__ */ new Map();
+  constructor(t, e, n) {
+    this._name = t, this._schema = e, this._collectionName = n || t.toLowerCase() + "s";
+    for (const [i, s] of e.getStatics())
+      this[i] = s.bind(this);
+    l.models.set(t, this);
+  }
+  get modelName() {
+    return this._name;
+  }
+  get schema() {
+    return this._schema;
+  }
+  get collection() {
+    return { name: this._collectionName };
+  }
+  getCollection() {
+    if (!h.db)
+      throw new Error("[Harbor] Not connected to database. Call harbor.connect() first.");
+    return h.db.collection(this._collectionName);
+  }
+  // Create a new document instance
+  new(t) {
+    return new _(this, t);
+  }
+  // Hydrate a plain object into a document
+  hydrate(t) {
+    const e = new _(this, t);
+    return e.isNew = !1, e;
+  }
+  // Query methods
+  find(t, e, n) {
+    const i = new u(this, "find", t);
+    return e && i.select(e), n?.sort && i.sort(n.sort), n?.limit && i.limit(n.limit), n?.skip && i.skip(n.skip), n?.lean && i.lean(), i;
+  }
+  findOne(t, e, n) {
+    const i = new u(this, "findOne", t);
+    return e && i.select(e), n?.lean && i.lean(), i;
+  }
+  findById(t, e, n) {
+    return this.findOne({ _id: new c(t) }, e, n);
+  }
+  // Create methods
+  async create(t) {
+    if (Array.isArray(t)) {
+      const n = [];
+      for (const i of t) {
+        const s = this.new(i);
+        await s.save(), n.push(s);
+      }
+      return n;
+    }
+    const e = this.new(t);
+    return await e.save(), e;
+  }
+  async insertMany(t, e) {
+    const n = this.getCollection(), i = t.map((o) => ({ _id: new c(), ...o })), s = await n.insertMany(i, { ordered: e?.ordered ?? !0 });
+    return {
+      insertedCount: s.insertedCount,
+      insertedIds: Object.values(s.insertedIds).map((o) => o.toString())
+    };
+  }
+  // Update methods
+  async updateOne(t, e, n) {
+    await this.runPreHooks("updateOne", null);
+    const i = this.getCollection(), s = e.$set || e.$unset || e.$inc ? e : { $set: e }, o = await i.updateOne(t, s, { upsert: n?.upsert });
+    return await this.runPostHooks("updateOne", null), {
+      acknowledged: o.acknowledged,
+      modifiedCount: o.modifiedCount,
+      matchedCount: o.matchedCount,
+      upsertedCount: o.upsertedCount,
+      upsertedId: o.upsertedId?.toString()
+    };
+  }
+  async updateMany(t, e, n) {
+    await this.runPreHooks("updateMany", null);
+    const i = this.getCollection(), s = e.$set || e.$unset || e.$inc ? e : { $set: e }, o = await i.updateMany(t, s, { upsert: n?.upsert });
+    return await this.runPostHooks("updateMany", null), {
+      acknowledged: o.acknowledged,
+      modifiedCount: o.modifiedCount,
+      matchedCount: o.matchedCount
+    };
+  }
+  findOneAndUpdate(t, e, n) {
+    const i = new u(this, "findOneAndUpdate", t, e);
+    return n?.new && (i._options.new = !0), n?.upsert && (i._options.upsert = !0), n?.lean && i.lean(), i;
+  }
+  findByIdAndUpdate(t, e, n) {
+    return this.findOneAndUpdate({ _id: new c(t) }, e, n);
+  }
+  async replaceOne(t, e, n) {
+    const s = await this.getCollection().replaceOne(t, e, { upsert: n?.upsert });
+    return {
+      acknowledged: s.acknowledged,
+      modifiedCount: s.modifiedCount,
+      matchedCount: s.matchedCount
+    };
+  }
+  // Delete methods
+  async deleteOne(t) {
+    await this.runPreHooks("deleteOne", null);
+    const n = await this.getCollection().deleteOne(t);
+    return await this.runPostHooks("deleteOne", null), {
+      acknowledged: n.acknowledged,
+      deletedCount: n.deletedCount
+    };
+  }
+  async deleteMany(t) {
+    await this.runPreHooks("deleteMany", null);
+    const n = await this.getCollection().deleteMany(t);
+    return await this.runPostHooks("deleteMany", null), {
+      acknowledged: n.acknowledged,
+      deletedCount: n.deletedCount
+    };
+  }
+  findOneAndDelete(t, e) {
+    const n = new u(this, "findOneAndDelete", t);
+    return e?.lean && n.lean(), n;
+  }
+  findByIdAndDelete(t, e) {
+    return this.findOneAndDelete({ _id: new c(t) }, e);
+  }
+  // Count methods
+  async countDocuments(t) {
+    return this.getCollection().countDocuments(t || {});
+  }
+  async estimatedDocumentCount() {
+    return this.getCollection().estimatedDocumentCount();
+  }
+  // Aggregate
+  async aggregate(t, e) {
+    return this.getCollection().aggregate(t, e).toArray();
+  }
+  // Distinct
+  async distinct(t, e) {
+    return this.getCollection().distinct(t, e || {});
+  }
+  // Exists
+  async exists(t) {
+    const e = await this.findOne(t).select({ _id: 1 }).lean();
+    return e ? { _id: e._id.toString() } : null;
+  }
+  // Bulk operations
+  async bulkWrite(t) {
+    const n = await this.getCollection().bulkWrite(t);
+    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(t, e) {
+    return this.getCollection().createIndex(t, e);
+  }
+  async createIndexes(t) {
+    const e = this.getCollection(), n = t.map((i) => ({ key: i.fields, ...i.options }));
+    return e.createIndexes(n);
+  }
+  async listIndexes() {
+    return this.getCollection().listIndexes().toArray();
+  }
+  async dropIndex(t) {
+    await this.getCollection().dropIndex(t);
+  }
+  // Populate
+  async populate(t, e) {
+    return t;
+  }
+  // Watch (change streams)
+  watch(t, e) {
+    return this.getCollection().watch(t, e);
+  }
+  // Hook execution
+  async runPreHooks(t, e) {
+    const n = this._schema.getPreHooks().get(t) || [];
+    for (const i of n)
+      await new Promise((s, o) => {
+        try {
+          const a = i.call(e, s);
+          a instanceof Promise && a.then(s).catch(o);
+        } catch (a) {
+          o(a);
+        }
+      });
+  }
+  async runPostHooks(t, e) {
+    const n = this._schema.getPostHooks().get(t) || [];
+    for (const i of n)
+      await new Promise((s, o) => {
+        try {
+          const a = i.call(e, s);
+          a instanceof Promise && a.then(s).catch(o);
+        } catch (a) {
+          o(a);
+        }
+      });
+  }
+}
+function O(r, t, e) {
+  const n = l.models.get(r);
+  return n || new l(r, t, e);
+}
+const P = {
+  ObjectId: c
+}, I = {
+  // Connection
+  connection: h,
+  connect: C,
+  disconnect: k,
+  // Schema & Model
+  Schema: p,
+  Model: l,
+  model: O,
+  // Types
+  Types: P,
+  // Convenience methods
+  get models() {
+    return Object.fromEntries(l.models);
+  },
+  // Version
+  version: "1.0.0"
+};
+export {
+  _ as H,
+  l as M,
+  u as Q,
+  p as S,
+  P as T,
+  C as a,
+  j as b,
+  h as c,
+  k as d,
+  M as e,
+  v as f,
+  H as g,
+  I as h,
+  O as m,
+  $ as r,
+  A as s,
+  f as t
+};
+//# sourceMappingURL=index-DIVHd6rO.mjs.map