tsledge 0.1.4 → 0.1.6

package/dist/tests/main.js

@@ -0,0 +1,932 @@
+// tests/main.ts
+import dotenv from "dotenv";
+
+// src/db/mongodb.ts
+import mongoose from "mongoose";
+
+// src/exitCodes.ts
+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/validation.ts
+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";
+
+// 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);
+    }
+    req.user = result.payload;
+    req.token = token;
+    next();
+  } catch (err) {
+    console.log("[ERROR] JWT validation error:", err);
+    return res.sendStatus(FORBIDDEN);
+  }
+}
+
+// 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 register(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);
+  }
+  let authUser = new AuthUser({
+    identifier,
+    secretHash: await bcrypt.hash(secret, 10)
+  });
+  authUser.save();
+  next();
+}
+async function login(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 logout(req, res, next) {
+  await jwtRefreshRequired(req, res, async () => {
+    const refreshToken = req.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 refreshJWT(req, res, next) {
+  const refreshToken = req.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);
+    }
+    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;
+  }
+};
+
+// 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/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;
+}
+
+// tests/models/user.ts
+import mongoose6 from "mongoose";
+var UserSchema = new mongoose6.Schema(
+  {
+    ofUserGroup: {
+      type: mongoose6.Schema.Types.ObjectId,
+      ref: "UserGroup",
+      alias: "userGroup",
+      required: true
+    },
+    username: { type: String, unique: true, required: true },
+    email: { type: String, unique: true, required: true, select: false },
+    secretHash: { type: String, select: false }
+  },
+  { collection: "users", timestamps: true }
+);
+UserSchema.set("toJSON", {
+  transform: (_doc, ret) => {
+    delete ret.secretHash;
+    return ret;
+  }
+});
+var user_default = mongoose6.model("User", UserSchema);
+
+// tests/routes.ts
+import { Router } from "express";
+
+// tests/fluent-api.ts
+import express3 from "express";
+import mongoose7 from "mongoose";
+var router2 = express3.Router();
+router2.get(
+  "/:collection",
+  async (req, res) => {
+    let collectionName = req.params.collection;
+    try {
+      if (!collectionName) {
+        console.log(`[ERROR] Collection name is required in the route parameter`);
+        res.status(400).json({});
+        return;
+      }
+      let model;
+      for (const modelName in mongoose7.models) {
+        let searchModel = mongoose7.models[modelName];
+        if (!searchModel) {
+          continue;
+        }
+        if (searchModel.collection.name === collectionName) {
+          model = searchModel;
+          break;
+        }
+      }
+      if (!model) {
+        console.log(`[ERROR] No model found for collection: ${collectionName}`);
+        res.status(400).json({});
+        return;
+      }
+      let queryBuilder = new QueryBuilder({
+        model
+      });
+      let codec = await FluentPatternHandler.getInstance().exec(req, queryBuilder);
+      codec.sendToClient(res);
+    } catch (e) {
+      console.log(e);
+      res.status(500).json();
+    }
+  }
+);
+var fluent_api_default = router2;
+
+// tests/auth.ts
+import express4 from "express";
+var router3 = express4.Router();
+router3.post("/register", register, async (req, res) => {
+  res.status(200).json({});
+});
+router3.post("/login", login, async (req, res) => {
+  res.status(200).json(res.locals.credentials);
+});
+router3.post("/logout", logout, async (req, res) => {
+  res.status(200).json({});
+});
+router3.post("/refresh", refreshJWT, async (req, res) => {
+  res.status(200).json({});
+});
+router3.get("/secure", jwtRequired, async (req, res) => {
+  res.status(200).json({});
+});
+var auth_default = router3;
+
+// tests/routes.ts
+var router4 = Router();
+router4.use("/fluent", fluent_api_default);
+router4.use("/auth", auth_default);
+var routes_default = router4;
+
+// tests/models/user-group.ts
+import mongoose8 from "mongoose";
+var UserGroupSchema = new mongoose8.Schema(
+  {
+    name: { type: String, unique: true, required: true }
+  },
+  { collection: "user_groups", timestamps: true }
+);
+var user_group_default = mongoose8.model("UserGroup", UserGroupSchema);
+
+// tests/main.ts
+dotenv.config();
+var PORT = process.env.PORT || 3e3;
+var URI = process.env.MONGODB_URI;
+var fluentApi = [
+  {
+    model: user_default,
+    filters: ["username"]
+  },
+  {
+    model: user_group_default
+  }
+];
+async function setup() {
+  new FluentPatternHandler(fluentApi);
+  connectMongoDB(URI).then(() => {
+    let app = createApp();
+    app.use("/", routes_default);
+    app.listen(PORT, () => {
+      console.log(`Server running on port ${PORT}`);
+    });
+  });
+}
+setup();
+export {
+  setup
+};