tsledge 0.1.3 → 0.1.5

package/dist/index.js

@@ -1,25 +1,1002 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+// src/db/mongodb.ts
+import mongoose from "mongoose";
+
+// src/exitCodes.ts
+var EXIT_CODE_SUCCESS = 0;
+var EXIT_CODE_GENERAL_ERROR = 1;
+var EXIT_CODE_INVALID_CONFIG = 2;
+
+// src/utils/date.ts
+function getCurrentDateString() {
+  let date = /* @__PURE__ */ new Date();
+  return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+}
+
+// src/utils/mongo-relation.ts
+function insertCollectionRelations(model, relations, compareFunc, validateFunc = void 0) {
+  if (relations == void 0) {
+    return;
+  }
+  let relationStack = [];
+  for (let relation of relations) {
+    if (validateFunc) {
+      relation = validateFunc(relation);
+    }
+    let inStack = false;
+    for (let duplicateRelationCheck of relationStack) {
+      if (compareFunc(relation, duplicateRelationCheck)) {
+        inStack = true;
+      }
+    }
+    if (!inStack) {
+      relationStack.push(relation);
+    }
+  }
+  if (relationStack.length > 0) {
+    model.insertMany(relationStack);
+  }
+}
+async function mergeCollectionRelations(model, relationsToMerge, match, compareFunc, validateFunc) {
+  const relationStack = [];
+  if (relationsToMerge != null) {
+    for (const relation of relationsToMerge) {
+      const validatedRelation = validateFunc(relation);
+      if (!relationStack.some(
+        (duplicateRelationCheck) => compareFunc(validatedRelation, duplicateRelationCheck)
+      )) {
+        relationStack.push(validatedRelation);
+      }
+    }
+  }
+  if (relationStack.length === 0) {
+    await model.deleteMany(match);
+  } else {
+    const existingRels = await model.find(match).lean();
+    const toRemoveRels = [];
+    for (const rel of existingRels) {
+      if (!relationStack.some((relationFromStack) => compareFunc(rel, relationFromStack))) {
+        toRemoveRels.push(rel);
+      }
+    }
+    const toCreateRels = [];
+    for (const relationFromStack of relationStack) {
+      if (!existingRels.some((rel) => compareFunc(rel, relationFromStack))) {
+        toCreateRels.push(relationFromStack);
+      }
+    }
+    if (toCreateRels.length > 0) {
+      await model.insertMany(toCreateRels);
+    }
+    if (toRemoveRels.length > 0) {
+      const idsToRemove = toRemoveRels.map((rel) => rel._id);
+      await model.deleteMany({ _id: { $in: idsToRemove } });
+    }
+  }
+}
+
+// src/utils/validation.ts
+function isNonEmptyObjectOrArray(value) {
+  return value != null && value != void 0 && (Array.isArray(value) && value.length > 0 || typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0);
+}
+function validateString(value, fallback = null) {
+  if (value !== void 0 && value !== null && value !== "" && value !== "undefined" && value !== "null") {
+    return value;
+  }
+  return fallback;
+}
+
+// src/utils/env.ts
+var JwtSecret = process.env.JWT_SECRET || "secret";
+var JwtRefreshSecret = process.env.JWT_REFRESH_SECRET || "refresh_secret";
+function isDebug(func = void 0) {
+  const dbg = process.env.DEBUG;
+  if (dbg !== void 0) {
+    const v = dbg.toString().trim().toLowerCase();
+    let validation = v === "1" || v === "true" || v === "yes" || v === "on";
+    if (validation && func != void 0) {
+      func();
+    }
+    return validation;
+  }
+  return false;
+}
+
+// src/utils/encoding.ts
+function encodeToBase64(obj) {
+  return btoa(encodeURIComponent(JSON.stringify(obj)));
+}
+
+// src/db/mongodb.ts
+async function connectMongoDB(uri) {
+  if (uri == null || uri == void 0 || uri.length == 0) {
+    console.error(`\u{1F6D1} [${getCurrentDateString()}] Error: MongoDB URI is not provided`);
+    process.exit(EXIT_CODE_INVALID_CONFIG);
+  }
+  try {
+    await mongoose.connect(uri);
+    console.log(`\u2705 [${getCurrentDateString()}] MongoDB connected`);
+  } catch (err) {
+    console.error(`\u{1F6D1} [${getCurrentDateString()}] Error: MongoDB connection failed`, err);
+    process.exit(EXIT_CODE_GENERAL_ERROR);
+  }
+}
+
+// src/middleware/file-storage.ts
+import multer from "multer";
+import path from "node:path";
+import fs from "node:fs";
+var uploadDir = path.resolve(process.cwd(), "src", "files");
+fs.mkdirSync(uploadDir, { recursive: true });
+var sanitizeFilename = (name) => name.replace(/[^a-zA-Z0-9._-]/g, "_");
+var diskStorage = multer.diskStorage({
+  destination: (_req, _file, next) => next(null, uploadDir),
+  filename: (_req, file, next) => {
+    const ext = path.extname(file.originalname);
+    const base = path.basename(file.originalname, ext);
+    const safe = sanitizeFilename(base);
+    const unique = Date.now() + "-" + Math.round(Math.random() * 1e9);
+    next(null, `${safe}-${unique}${ext}`);
+  }
+});
+var memoryStorage = multer.memoryStorage();
+var diskFileUpload = multer({ storage: diskStorage });
+var memoryFileUpload = multer({ storage: memoryStorage });
+
+// src/middleware/logger.ts
+function requestLogger(req, res, next) {
+  res.on("finish", () => {
+    let emoji = "";
+    if (res.statusCode >= 100 && res.statusCode < 200) emoji = "\u{1F4A1}";
+    else if (res.statusCode >= 200 && res.statusCode < 300) emoji = "\u2705";
+    else if (res.statusCode >= 300 && res.statusCode < 400) emoji = "\u{1F6A6}";
+    else if (res.statusCode == 401) emoji = "\u{1F501}";
+    else if (res.statusCode >= 400 && res.statusCode < 500) emoji = "\u26A0\uFE0F";
+    else if (res.statusCode >= 500) emoji = "\u{1F525}";
+    console.log(
+      `${emoji} [${getCurrentDateString()}] ${req.method} ${req.originalUrl} - ${res.statusCode}`
+    );
+  });
+  next();
+}
+function errorLogger(err, req, res, next) {
+  console.error(`\u{1F6D1} [${getCurrentDateString()}] Error in ${req.method} ${req.originalUrl}:`, err);
+  res.status(500).json();
+}
+
+// src/middleware/authentication/session.ts
+import express from "express";
+
+// src/models/auth-user.ts
+import mongoose2 from "mongoose";
+var AuthUserSchema = new mongoose2.Schema(
+  {
+    identifier: { type: String, unique: true, required: true },
+    secretHash: { type: String, select: false },
+    blockedSince: { type: Date }
+  },
+  { collection: "auth_users", timestamps: true }
+);
+var AuthUser = mongoose2.model("AuthUser", AuthUserSchema);
+
+// src/models/token-blocklist.ts
+import mongoose3 from "mongoose";
+var TokenBlocklistSchema = new mongoose3.Schema(
+  {
+    jti: { type: String, required: true }
+  },
+  { collection: "token_blocklist", timestamps: true }
+);
+var TokenBlocklist = mongoose3.model("TokenBlocklist", TokenBlocklistSchema);
+
+// src/middleware/authentication/session.ts
+import bcrypt from "bcrypt";
+import jwt2 from "jsonwebtoken";
+
+// src/middleware/authentication/validation.ts
+import jwt from "jsonwebtoken";
+var FORBIDDEN = 403;
+var UNAUTHORIZED = 401;
+async function jwtRequired(req, res, next) {
+  return validateJwt(req, res, next, JwtSecret);
+}
+async function jwtRefreshRequired(req, res, next) {
+  return validateJwt(req, res, next, JwtRefreshSecret);
+}
+async function verifyToken(token, jwtSecret) {
+  try {
+    const payload = jwt.verify(token, jwtSecret, { ignoreExpiration: true });
+    const jti = payload?.jti;
+    if (!jti) {
+      console.log("[WARN] JWT token without jti");
+      return { isTokenValid: false, isTokenExpired: false, isUserBlocked: false, payload };
+    }
+    const existingBlock = await TokenBlocklist.findOne({ jti });
+    if (existingBlock) {
+      console.log("[WARN] JWT token is blocked");
+      return { isTokenValid: false, isTokenExpired: false, isUserBlocked: false, payload };
+    }
+    const identifier = payload.identifier;
+    if (identifier) {
+      const user = await AuthUser.findOne({ identifier });
+      if (!user) {
+        console.log("[WARN] JWT token for non-existing user");
+        return { isTokenValid: false, isTokenExpired: false, isUserBlocked: false, payload };
+      }
+      if (user.blockedSince != void 0) {
+        console.log("[WARN] JWT token for blocked user");
+        return { isTokenValid: false, isTokenExpired: false, isUserBlocked: true, payload };
+      }
+    } else {
+      console.log("[WARN] JWT token without identifier");
+      return { isTokenValid: false, isTokenExpired: false, isUserBlocked: false, payload };
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    if (payload.exp && payload.exp < now) {
+      if (jwtSecret == JwtSecret) {
+        console.log("[WARN] Access token expired");
+        return { isTokenValid: false, isTokenExpired: true, isUserBlocked: false, payload };
+      } else {
+        console.log("[WARN] Refresh token expired");
+        return { isTokenValid: false, isTokenExpired: false, isUserBlocked: false, payload };
+      }
+    }
+    return { isTokenValid: true, isTokenExpired: false, isUserBlocked: false, payload };
+  } catch (err) {
+    console.log("[WARN] JWT verification error:", err.message);
+    return {
+      isTokenValid: false,
+      isTokenExpired: false,
+      payload: null,
+      isUserBlocked: false
+    };
+  }
+}
+async function validateJwt(req, res, next, jwtSecret) {
+  const authHeader = req.headers["authorization"];
+  if (!authHeader) return res.sendStatus(FORBIDDEN);
+  const token = authHeader.split(" ")[1];
+  if (!token) return res.sendStatus(FORBIDDEN);
+  try {
+    const result = await verifyToken(token, jwtSecret);
+    if (result.isTokenExpired) {
+      console.log("[WARN] Expired JWT token");
+      return res.sendStatus(UNAUTHORIZED);
+    }
+    if (!result.isTokenValid) {
+      console.log("[WARN] Invalid JWT token");
+      return res.sendStatus(FORBIDDEN);
+    }
+    if (result.isUserBlocked) {
+      console.log("[WARN] JWT token for blocked user");
+      return res.sendStatus(FORBIDDEN);
+    }
+    res.locals.user = result.payload;
+    res.locals.token = token;
+    next();
+  } catch (err) {
+    console.log("[ERROR] JWT validation error:", err);
+    return res.sendStatus(FORBIDDEN);
+  }
+}
+async function socketToken(_socket, _next) {
+  const token = _socket.handshake.auth?.token;
+  if (!token) {
+    return _next();
+  }
+  try {
+    const verificationResult = await verifyToken(token, JwtSecret);
+    const isValidChar = verificationResult.isTokenValid && !verificationResult.isTokenExpired ? "\u{1F7E2}" : "\u{1F534}";
+    console.log(`${isValidChar} Socket verification result: ${JSON.stringify(verificationResult)}`);
+    if (!verificationResult.isTokenValid) {
+      if (verificationResult.isTokenExpired) {
+        return _next(new Error("expired_token"));
+      }
+      return _next(new Error("invalid_token"));
+    }
+    _socket.user = verificationResult.payload;
+    _next();
+  } catch (err) {
+    return _next(new Error("invalid_token"));
+  }
+}
+
+// src/middleware/authentication/session.ts
+var router = express.Router();
+var FORBIDDEN2 = 403;
+var BAD_REQUEST = 400;
+async function generateCredentials(auth) {
+  let jti = void 0;
+  let blocked = void 0;
+  do {
+    jti = crypto.randomUUID();
+    blocked = await TokenBlocklist.findOne({ jti });
+  } while (blocked != void 0);
+  const user = await AuthUser.findOne({ identifier: auth.identifier }).lean();
+  if (!user) {
+    return void 0;
+  }
+  let appUser = void 0;
+  try {
+    appUser = encodeToBase64(user);
+  } catch (error) {
+  }
+  if (!appUser) {
+    return void 0;
+  }
+  let payload = {
+    identifier: auth.identifier,
+    jti
+  };
+  const accessToken = jwt2.sign(payload, JwtSecret, { expiresIn: "1h" });
+  const refreshToken = jwt2.sign(payload, JwtRefreshSecret, { expiresIn: "7d" });
+  return {
+    accessToken,
+    refreshToken,
+    appUser
+  };
+}
+async function authRegister(req, res, next) {
+  let { identifier = void 0, secret = void 0 } = req.body || {};
+  if (!identifier || !secret) {
+    return res.sendStatus(FORBIDDEN2);
+  }
+  identifier = identifier.toLowerCase();
+  let user = await AuthUser.findOne({ identifier });
+  if (user) {
+    return res.sendStatus(BAD_REQUEST);
+  }
+  res.locals.authUser = new AuthUser({
+    identifier,
+    secretHash: await bcrypt.hash(secret, 10)
+  });
+  next();
+}
+async function authLogin(req, res, next) {
+  let { identifier = void 0, secret = void 0 } = req.body || {};
+  if (!identifier || !secret) {
+    return res.sendStatus(FORBIDDEN2);
+  }
+  identifier = identifier.toLowerCase();
+  let user = await AuthUser.findOne({ identifier }).select("+secretHash");
+  if (!user || !user.secretHash) {
+    return res.sendStatus(BAD_REQUEST);
+  }
+  if (user.blockedSince) {
+    return res.sendStatus(FORBIDDEN2);
+  }
+  let isMatch = await bcrypt.compare(secret, user.secretHash);
+  if (!isMatch) {
+    return res.sendStatus(BAD_REQUEST);
+  }
+  let credentials = await generateCredentials(user);
+  if (!credentials) {
+    return res.sendStatus(BAD_REQUEST);
+  }
+  res.locals.credentials = credentials;
+  next();
+}
+async function authLogout(req, res, next) {
+  await jwtRefreshRequired(req, res, async () => {
+    const refreshToken = res.locals.token;
+    if (!refreshToken) {
+      return res.sendStatus(BAD_REQUEST);
+    }
+    const decoded = jwt2.decode(refreshToken);
+    const jti = decoded?.jti;
+    if (jti) {
+      const existingBlock = await TokenBlocklist.findOne({ jti });
+      if (!existingBlock) {
+        await new TokenBlocklist({ jti }).save();
+      }
+    }
+    let accessToken = validateString(req.body?.access_token);
+    if (accessToken) {
+      const accessTokenDecoded = jwt2.decode(accessToken);
+      let accessTokenJti = accessTokenDecoded?.jti;
+      if (accessTokenJti) {
+        const existing = await TokenBlocklist.findOne({ jti: accessTokenJti });
+        if (!existing) {
+          await new TokenBlocklist({ jti: accessTokenJti }).save();
+        }
+      }
+    }
+    next();
+  });
+}
+async function authRefresh(req, res, next) {
+  await jwtRefreshRequired(req, res, async () => {
+  });
+  const refreshToken = res.locals.token;
+  if (!refreshToken) {
+    return res.sendStatus(BAD_REQUEST);
+  }
+  try {
+    const decoded = jwt2.decode(refreshToken);
+    const jti = decoded?.jti;
+    if (jti) {
+      const existingBlock = await TokenBlocklist.findOne({ jti });
+      if (!existingBlock) {
+        await new TokenBlocklist({ jti }).save();
+      }
+    }
+    let accessToken = validateString(req.body?.access_token);
+    if (accessToken) {
+      const accessTokenDecoded = jwt2.decode(accessToken);
+      let accessTokenJti = accessTokenDecoded?.jti;
+      if (accessTokenJti) {
+        const existing = await TokenBlocklist.findOne({
+          jti: accessTokenJti
+        });
+        if (!existing) {
+          await new TokenBlocklist({ jti: accessTokenJti }).save();
+        }
+      }
+    }
+    const payload = jwt2.verify(refreshToken, JwtRefreshSecret);
+    let credentials = await generateCredentials(payload);
+    if (!credentials) {
+      return res.sendStatus(BAD_REQUEST);
+    }
+    res.locals.credentials = credentials;
+    next();
+  } catch (err) {
+    console.log("[WARN] refreshing JWT:", err);
+    return res.sendStatus(BAD_REQUEST);
+  }
+}
+
+// src/fluent-interface/fluent-pattern-handler.ts
+import mongoose5 from "mongoose";
+
+// src/fluent-interface/types.ts
+var fluentRequestQueryAttributes = {
+  id: "",
+  ids: "",
+  filter: "",
+  offset: "",
+  limit: "",
+  order: "",
+  excluded: ""
+};
+
+// src/core/query-builder.ts
+import mongoose4 from "mongoose";
+
+// src/core/types.ts
+var Codec = class {
+  constructor(content, code = 202) {
+    this.content = content;
+    this.returnCode = code;
+  }
+  sendToClient(res) {
+    if (this.content == null) {
+      res.status(404).json({});
+    }
+    res.status(this.returnCode).json(this.content);
+  }
+  is1xx() {
+    return this.returnCode >= 100 && this.returnCode <= 199;
+  }
+  is2xx() {
+    return this.returnCode >= 200 && this.returnCode <= 299;
+  }
+  is3xx() {
+    return this.returnCode >= 300 && this.returnCode <= 399;
+  }
+  is4xx() {
+    return this.returnCode >= 400 && this.returnCode <= 499;
+  }
+};
+var JoinRelation = class {
+  constructor(localField, ref, alias = void 0) {
+    this.ref = ref;
+    this.localField = localField;
+    this.alias = alias ? alias : ref.collection.name;
+  }
+};
+var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
+  HttpMethod2["POST"] = "post";
+  HttpMethod2["GET"] = "get";
+  HttpMethod2["DELETE"] = "delete";
+  HttpMethod2["PUT"] = "put";
+  return HttpMethod2;
+})(HttpMethod || {});
+
+// src/core/query-builder.ts
+var QueryBuilder = class {
+  constructor(config) {
+    this._matchConditions = {};
+    this._stages = [];
+    this._relations = [];
+    this._unsetFields = [];
+    this._config = config;
+    this._applyPathOptions();
+  }
+  /**
+   * Generates the aggregation pipeline based on the current configuration of the QueryBuilder.
+   * @returns
+   */
+  getAggregationPipeline() {
+    return this._generatePipeline();
+  }
+  /**
+   * Returns the current configuration of the QueryBuilder, including model, select fields, and any applied options.
+   * @returns
+   */
+  getConfig() {
+    return this._config;
+  }
+  /**
+   * Applies schema-based options such as joins and unset fields.
+   */
+  _applyPathOptions() {
+    this._generateSchemaJoins(this._config.model.schema);
+    this._generateSchemaUnsetList(this._config);
+  }
+  /**
+   * Adds match conditions to the query builder.
+   * @param match - The match conditions to add.
+   * @param conjunction - The logical conjunction ('and' or 'or').
+   * @param append - Whether to append to existing conditions or replace them.
+   */
+  match(match, conjunction = "and", append = true) {
+    if (!match || (Array.isArray(match) ? match.length === 0 : Object.keys(match).length === 0))
+      return;
+    if (!append) {
+      this._matchConditions = Array.isArray(match) ? { $and: match } : match;
+      return;
+    }
+    const key = `$${conjunction}`;
+    if (!this._matchConditions[key]) this._matchConditions[key] = [];
+    if (Array.isArray(match)) {
+      this._matchConditions[key].push(...match);
+    } else {
+      this._matchConditions[key].push(match);
+    }
+  }
+  /**
+   * Adds aggregation stages to the query builder.
+   * @param stages
+   * @returns
+   */
+  stage(stages) {
+    if (!stages) return;
+    if (Array.isArray(stages)) {
+      this._stages.push(...globalThis.structuredClone(stages));
+    } else {
+      this._stages.push(globalThis.structuredClone(stages));
+    }
+  }
+  /**
+   * Adds join relations to the query builder.
+   * @param rels
+   * @returns
+   */
+  join(rels) {
+    if (!rels) return;
+    const list = Array.isArray(rels) ? rels : [rels];
+    list.forEach((rel) => this._relations.push(rel));
+  }
+  /**
+   * Calculates the $lookup stage for a given JoinRelation.
+   * @param relation
+   * @returns
+   */
+  _calculateJoin(relation) {
+    if (!(relation instanceof JoinRelation)) throw new Error("relation must be JoinRelation");
+    return {
+      $lookup: {
+        from: relation.ref.collection.name,
+        localField: relation.localField,
+        foreignField: "_id",
+        as: relation.alias
+      }
+    };
+  }
+  /**
+   * Automatically generates JoinRelation objects from schema refs.
+   * @param model The Mongoose model to scan.
+   * @param prefix Optional prefix for nested paths (e.g., 'alias.field').
+   * @returns Array of JoinRelation objects.
+   */
+  _generateSchemaJoins(schema, prefix = "") {
+    schema.eachPath((path2, schematype) => {
+      const fullPath = prefix ? `${prefix}.${path2}` : path2;
+      if (schematype.options?.ref) {
+        const refModelName = schematype.options.ref;
+        try {
+          const refModel = mongoose4.model(refModelName);
+          let alias = schematype.options?.alias ?? refModel.collection.name;
+          this.join(new JoinRelation(fullPath, refModel, alias));
+        } catch (err) {
+          console.warn(
+            `[QueryBuilder] Could not resolve ref model '${refModelName}' for path '${fullPath}'`
+          );
+        }
+      }
+      if (schematype instanceof mongoose4.Schema.Types.Array && schematype.caster?.options?.ref) {
+        const refModelName = schematype.caster.options.ref;
+        try {
+          const refModel = mongoose4.model(refModelName);
+          let alias = schematype.caster.options?.alias ?? refModel.collection.name;
+          this.join(new JoinRelation(fullPath, refModel, alias));
+        } catch (err) {
+          console.warn(
+            `[QueryBuilder] Could not resolve array ref model '${refModelName}' for path '${fullPath}'`
+          );
+        }
+      }
+    });
+  }
+  /**
+   * Generates the list of fields to unset based on schema select options.
+   * @param config - The query request configuration.
+   */
+  _generateSchemaUnsetList(config) {
+    this._unsetFields = [];
+    let unset = this._collectSelectFalse(config.model.schema, void 0, config.select);
+    for (const relation of this._relations) {
+      unset = unset.concat(
+        this._collectSelectFalse(relation.ref.schema, relation.alias, config.select)
+      );
+    }
+    this._unsetFields = Array.from(new Set(unset));
+  }
+  /**
+   * Collects paths from the schema where select is set to false.
+   * @param schema - The Mongoose schema to scan.
+   * @param prefix - Optional prefix for nested paths.
+   * @param select - Optional array of fields to select.
+   * @returns Array of paths to unset.
+   */
+  _collectSelectFalse(schema, prefix = void 0, select = void 0) {
+    const unset = [];
+    schema.eachPath((path2, schematype) => {
+      if (select && select.length > 0 && !select.includes(path2) && schematype?.options?.select !== false) {
+        return;
+      }
+      if (schematype?.options?.select === false) {
+        unset.push(prefix ? `${prefix}.${path2}` : path2);
+      }
+    });
+    return unset;
+  }
+  /**
+   * Generates the aggregation pipeline based on joins, stages, match conditions, and unset fields.
+   * @returns The aggregation pipeline array.
+   */
+  _generatePipeline() {
+    const pipeline = [];
+    for (const rel of this._relations) {
+      pipeline.push(this._calculateJoin(rel));
+    }
+    pipeline.push(...this._stages);
+    if (Object.keys(this._matchConditions).length) {
+      pipeline.push({ $match: this._matchConditions });
+    }
+    if (this._unsetFields.length) {
+      pipeline.push({ $unset: this._unsetFields });
+    }
+    return pipeline;
+  }
+  /**
+   * Executes the aggregation pipeline and returns the results.
+   * @param config - Parameters for the query execution.
+   * @returns The collection response wrapped in a Codec.
+   */
+  async exec(config) {
+    try {
+      const pipeline = this._generatePipeline();
+      const countPipeline = [...pipeline, { $count: "n" }];
+      const queryPipeline = [...pipeline];
+      if (config && !config.isOne) {
+        if (config.skip) queryPipeline.push({ $skip: config.skip });
+        if (config.limit) queryPipeline.push({ $limit: config.limit });
+      }
+      const [countRes, res] = await Promise.all([
+        this._config.model.aggregate(countPipeline).exec(),
+        this._config.model.aggregate(queryPipeline).exec()
+      ]);
+      const totalCount = countRes && countRes[0] ? countRes[0].n : 0;
+      const documents = config && config.isOne ? await this._processSingleDocument(res) : await this._processMultipleDocuments(res);
+      return new Codec({ data: documents, meta: { total: totalCount } }, 200);
+    } catch (err) {
+      console.error("[ERROR - QueryBuilder]", err);
+      return new Codec({ data: [], meta: { total: 0 } }, 500);
+    }
+  }
+  /**
+   * Processes a single document from the aggregation result.
+   * @param res - The aggregation result array.
+   * @returns The processed document or null if none.
+   */
+  async _processSingleDocument(res) {
+    if (!res || res.length === 0) {
+      return null;
+    }
+    let doc = this._config.model.hydrate(res[0]);
+    if (this._config.eachFunc) {
+      doc = this._config.eachFunc(doc);
+    } else if (this._config.asyncEachFunc) {
+      doc = await this._config.asyncEachFunc(doc);
+    }
+    return doc;
+  }
+  /**
+   * Processes multiple documents from the aggregation result.
+   * @param res - The aggregation result array.
+   * @returns The array of processed documents.
+   */
+  async _processMultipleDocuments(res) {
+    let final = (res || []).map((doc) => this._config.model.hydrate(doc));
+    if (this._config.eachFunc) {
+      final = final.map(this._config.eachFunc);
+    } else if (this._config.asyncEachFunc) {
+      const asyncFinal = [];
+      for (const doc of final) {
+        const newDoc = await this._config.asyncEachFunc(doc);
+        asyncFinal.push(newDoc);
+      }
+      final = asyncFinal;
+    }
+    return final;
+  }
+};
+
+// src/core/http.ts
+function formDataParser(obj) {
+  return new URLSearchParams(obj).toString();
+}
+async function httpRequest(config) {
+  const url = new URL(config.url);
+  if (config.urlSearchParams) {
+    Object.keys(config.urlSearchParams).forEach((key) => {
+      url.searchParams.set(key, String(config.urlSearchParams[key]));
+    });
+  }
+  let body;
+  let defaultContentType = "application/x-www-form-urlencoded";
+  if (config.body) {
+    if (typeof config.body === "object") {
+      body = JSON.stringify(config.body);
+      defaultContentType = "application/json";
+    } else {
+      body = String(config.body);
+    }
+  }
+  const fetchImpl = globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error("fetch() is not available. Please use Node.js 18+ or add a fetch polyfill.");
+  }
+  const defaultHeaders = {};
+  if (!config.headers || !Object.keys(config.headers).find((key) => key.toLowerCase() === "content-type")) {
+    defaultHeaders["Content-Type"] = defaultContentType;
+  }
+  const response = await fetchImpl(url.toString(), {
+    method: config.method?.toUpperCase() || "GET",
+    body,
+    headers: {
+      ...defaultHeaders,
+      ...config.headers
+    }
+  });
+  const contentType = response.headers.get("content-type") || "";
+  const isJson = contentType.includes("application/json");
+  const isBlob = contentType.includes("application/octet-stream");
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`HTTP ${response.status} ${response.statusText}: ${text}`);
+  }
+  let result;
+  if (isJson) {
+    result = await response.json().catch(async (error) => {
+      throw new Error(`Failed to parse JSON response: ${error.message}`);
+    });
+  } else if (isBlob) {
+    result = await response.blob().catch(async (error) => {
+      throw new Error(`Failed to get blob response: ${error.message}`);
+    });
+  } else {
+    result = await response.text().catch(async (error) => {
+      throw new Error(`Failed to get text response: ${error.message}`);
+    });
+  }
+  return result;
+}
+
+// src/fluent-interface/fluent-pattern-handler.ts
+var FluentPatternHandler = class _FluentPatternHandler {
+  /**
+   * Constructor for QueryPatternExecutor.
+   * @param paths - Array of query pattern paths for filtering.
+   */
+  constructor(paths = []) {
+    if (_FluentPatternHandler._singleton) {
+      throw new Error(
+        "FluentPatternHandler is a singleton class. Use FluentPatternHandler.getInstance() to access the instance."
+      );
+    }
+    this._paths = paths;
+    _FluentPatternHandler._singleton = this;
+  }
+  static getInstance() {
+    if (_FluentPatternHandler._singleton == void 0) {
+      throw new Error(
+        "FluentPatternHandler instance has not been created yet. Please create an instance before calling getInstance()."
+      );
+    }
+    return _FluentPatternHandler._singleton;
+  }
+  /**
+   * Parses and validates query parameters from the request.
+   * @param query - The query object from the request.
+   * @returns Parsed query parameters.
+   */
+  _parseFluentRequestQuery(query) {
+    const { filter, limit = "5", offset = "0", id, excluded: excludedJSON, ids: idsJSON } = query;
+    const queryKeys = Object.keys(fluentRequestQueryAttributes);
+    let filterFields = {};
+    for (const [key, value] of Object.entries(query)) {
+      if (queryKeys.includes(key)) continue;
+      if (value == void 0) continue;
+      try {
+        filterFields[key] = typeof value === "string" ? value : JSON.stringify(value);
+      } catch (e) {
+        filterFields[key] = String(value);
+      }
+    }
+    let excluded;
+    if (excludedJSON) {
+      try {
+        excluded = JSON.parse(excludedJSON);
+        if (!Array.isArray(excluded)) throw new Error("Excluded must be an array");
+      } catch (error) {
+        console.warn("[QueryPatternExecutor] Invalid excluded parameter:", error);
+      }
+    }
+    let ids;
+    if (idsJSON) {
+      try {
+        ids = JSON.parse(idsJSON);
+        if (!Array.isArray(ids)) throw new Error("Ids must be an array");
+      } catch (error) {
+        console.warn("[QueryPatternExecutor] Invalid ids parameter:", error);
+      }
+    }
+    return { filter, limit, offset, id, excluded, ids, filterFields };
+  }
+  /**
+   * Applies filters to the query builder based on parsed parameters and options.
+   * @param queryBuilder - The QueryBuilder instance.
+   * @param params - Parsed query parameters.
+   * @param config - Query request configuration.
+   */
+  _applyParameters(queryBuilder, params) {
+    const { id, ids, filter, excluded } = params;
+    if (id) {
+      queryBuilder.match({ _id: new mongoose5.Types.ObjectId(id) });
+    } else if (ids && ids.length > 0) {
+      const objectIds = ids.map((id2) => new mongoose5.Types.ObjectId(id2));
+      queryBuilder.match({ _id: { $in: objectIds } });
+    } else {
+      const modelFilterFields = this._getFilterFieldsForModel(queryBuilder.getConfig().model);
+      if (filter && modelFilterFields.length > 0) {
+        const ors = modelFilterFields.map((field) => ({
+          [field]: { $regex: filter, $options: "i" }
+        }));
+        queryBuilder.match({ $or: ors });
+      }
+      if (params.filterFields && Object.keys(params.filterFields).length > 0) {
+        for (const [field, value] of Object.entries(params.filterFields)) {
+          if (!modelFilterFields.includes(field)) {
+            continue;
+          }
+          const match = {};
+          match[field] = { $regex: value, $options: "i" };
+          queryBuilder.match(match);
+        }
+      }
+      if (excluded && excluded.length > 0) {
+        const objectIds = excluded.map((id2) => new mongoose5.Types.ObjectId(id2));
+        queryBuilder.match({ _id: { $nin: objectIds } });
+      }
+    }
+  }
+  /**
+   * Retrieves filter fields for the given model from the paths configuration.
+   * @param model - The Mongoose model.
+   * @returns Array of filter fields.
+   */
+  _getFilterFieldsForModel(model) {
+    for (const path2 of this._paths) {
+      if (path2.model.collection.name === model.collection.name) {
+        if (path2.filters) {
+          return path2.filters;
+        }
+        return [];
+      }
+    }
+    return [];
+  }
+  /**
+   * Builds execution parameters for the query builder.
+   * @param params - Parsed query parameters.
+   * @returns Execution parameters.
+   */
+  _buildExecutionConfig(params) {
+    const { id, limit, offset } = params;
+    return {
+      isOne: Boolean(id),
+      limit: limit === "full" ? void 0 : parseInt(limit || "5", 10),
+      skip: parseInt(offset || "0", 10)
+    };
+  }
+  /**
+   * Executes the query builder with the applied filters and execution parameters.
+   * @param req
+   * @param queryBuilder
+   * @returns
+   */
+  async exec(req, queryBuilder) {
+    try {
+      const queryParams = this._parseFluentRequestQuery(req.query);
+      this._applyParameters(queryBuilder, queryParams);
+      const execConfig = this._buildExecutionConfig(queryParams);
+      return await queryBuilder.exec(execConfig);
+    } catch (err) {
+      console.error("[ERROR - QueryPatternExecutor]", err);
+      return new Codec({ data: [], meta: { total: 0 } }, 500);
+    }
+  }
+};
+
+// src/app.ts
+import express2 from "express";
+import cors from "cors";
+function createApp() {
+  const app = express2();
+  app.use(cors());
+  app.use(express2.json());
+  app.use(express2.urlencoded({ extended: true }));
+  app.use(requestLogger);
+  app.use(errorLogger);
+  return app;
+}
+export {
+  AuthUser,
+  Codec,
+  EXIT_CODE_GENERAL_ERROR,
+  EXIT_CODE_INVALID_CONFIG,
+  EXIT_CODE_SUCCESS,
+  FluentPatternHandler,
+  HttpMethod,
+  JoinRelation,
+  JwtRefreshSecret,
+  JwtSecret,
+  QueryBuilder,
+  TokenBlocklist,
+  authLogin,
+  authLogout,
+  authRefresh,
+  authRegister,
+  connectMongoDB,
+  createApp,
+  diskFileUpload,
+  encodeToBase64,
+  errorLogger,
+  fluentRequestQueryAttributes,
+  formDataParser,
+  getCurrentDateString,
+  httpRequest,
+  insertCollectionRelations,
+  isDebug,
+  isNonEmptyObjectOrArray,
+  jwtRefreshRequired,
+  jwtRequired,
+  memoryFileUpload,
+  mergeCollectionRelations,
+  requestLogger,
+  socketToken,
+  validateString,
+  verifyToken
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./db/index"), exports);
-__exportStar(require("./middleware/index"), exports);
-__exportStar(require("./fluent-interface/index"), exports);
-__exportStar(require("./core/index"), exports);
-__exportStar(require("./utils/index"), exports);
-__exportStar(require("./app"), exports);
-__exportStar(require("./types"), exports);
-__exportStar(require("./exitCodes"), exports);
-//# sourceMappingURL=index.js.map