tsledge-core 0.1.0

package/dist/bin/repl.js

@@ -0,0 +1,1181 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AuthTokenBlocklistModel: () => AuthTokenBlocklistModel,
+  AuthUserModel: () => AuthUserModel,
+  Codec: () => Codec,
+  EXIT_CODE_GENERAL_ERROR: () => EXIT_CODE_GENERAL_ERROR,
+  EXIT_CODE_INVALID_CONFIG: () => EXIT_CODE_INVALID_CONFIG,
+  EXIT_CODE_SUCCESS: () => EXIT_CODE_SUCCESS,
+  FluentPatternHandler: () => FluentPatternHandler,
+  HttpMethod: () => HttpMethod,
+  JoinRelation: () => JoinRelation,
+  JwtRefreshSecret: () => JwtRefreshSecret,
+  JwtSecret: () => JwtSecret,
+  QueryBuilder: () => QueryBuilder,
+  authLogin: () => authLogin,
+  authLogout: () => authLogout,
+  authRefresh: () => authRefresh,
+  authRegister: () => authRegister,
+  clamp: () => clamp,
+  connectMongoDB: () => connectMongoDB,
+  createApp: () => createApp,
+  decodeFromBase64: () => decodeFromBase64,
+  diskFileUpload: () => diskFileUpload,
+  encodeToBase64: () => encodeToBase64,
+  errorLogger: () => errorLogger,
+  fluentRequestQueryAttributes: () => fluentRequestQueryAttributes,
+  formDataParser: () => formDataParser,
+  getCurrentDateString: () => getCurrentDateString,
+  httpRequest: () => httpRequest,
+  insertCollectionRelations: () => insertCollectionRelations,
+  isDebug: () => isDebug,
+  isNonEmptyObjectOrArray: () => isNonEmptyObjectOrArray,
+  isNumberInRange: () => isNumberInRange,
+  jwtRefreshRequired: () => jwtRefreshRequired,
+  jwtRequired: () => jwtRequired,
+  memoryFileUpload: () => memoryFileUpload,
+  mergeCollectionRelations: () => mergeCollectionRelations,
+  mergeObjects: () => mergeObjects,
+  parseBoolean: () => parseBoolean,
+  parseList: () => parseList,
+  parseNumber: () => parseNumber,
+  requestLogger: () => requestLogger,
+  socketToken: () => socketToken,
+  validateString: () => validateString,
+  verifyToken: () => verifyToken
+});
+
+// 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;
+}
+function mergeObjects(input, target, prefix = void 0) {
+  if (input && typeof input === "object" && !Array.isArray(input)) {
+    if (target && typeof target === "object" && !Array.isArray(target)) {
+      Object.entries(input).forEach(([key, value]) => {
+        if (value != void 0 && value != null) {
+          if (prefix) {
+            target[`${prefix}.${key}`] = value;
+          } else {
+            target[key] = value;
+          }
+        }
+      });
+    }
+  }
+  return target;
+}
+function parseList(list, delimiter = ",") {
+  if (!list) return [];
+  if (Array.isArray(list)) return list.map((s) => String(s).trim()).filter(Boolean);
+  if (typeof list === "string") {
+    try {
+      const parsed = JSON.parse(list);
+      if (Array.isArray(parsed)) return parsed.map((s) => String(s).trim()).filter(Boolean);
+    } catch {
+    }
+    return list.split(delimiter).map((s) => s.trim()).filter(Boolean);
+  }
+  return [];
+}
+function parseNumber(value) {
+  if (value === void 0 || value === null) return null;
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  const parsedValue = String(value).trim();
+  if (parsedValue === "" || parsedValue === "undefined" || parsedValue === "null") {
+    return null;
+  }
+  if (!/^[-+]?(?:\d+|\d*\.\d+)$/.test(parsedValue)) {
+    return null;
+  }
+  if (parsedValue.includes(".")) {
+    return parseFloat(parsedValue);
+  }
+  return parseInt(parsedValue, 10);
+}
+function isNumberInRange(value, from = 0, to = 1) {
+  value = parseNumber(value);
+  if (value == null) {
+    return false;
+  }
+  return !isNaN(value) && value >= from && value <= to;
+}
+function clamp(value, from = 0, to = 1) {
+  value = parseNumber(value);
+  if (value == null) {
+    return from;
+  }
+  if (isNaN(value)) return from;
+  return Math.min(Math.max(value, from), to);
+}
+function parseBoolean(value, fallback = false) {
+  if (value === void 0 || value === null) return fallback;
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsedValue = value.trim().toLowerCase();
+    if (parsedValue === "true" || parsedValue === "1" || parsedValue == "yes") return true;
+    return false;
+  }
+  if (typeof value === "object") {
+    if (value instanceof Boolean) {
+      return value.valueOf();
+    }
+    return fallback;
+  }
+  if (typeof value === "number") {
+    if (value > 0) return true;
+  }
+  try {
+    return Boolean(value.trim().toLowerCase());
+  } catch {
+  }
+  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)));
+}
+function decodeFromBase64(str) {
+  if (str == null || str == void 0) {
+    return void 0;
+  }
+  let decoded = str ? decodeURIComponent(atob(str)) : void 0;
+  return decoded ? JSON.parse(decoded) : void 0;
+}
+
+// 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";
+import bcrypt from "bcrypt";
+import jwt2 from "jsonwebtoken";
+
+// src/middleware/authentication/validation.ts
+import jwt from "jsonwebtoken";
+
+// 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 AuthUserModel = mongoose2.model("AuthUser", AuthUserSchema);
+
+// src/models/auth-token-blocklist.ts
+import mongoose3 from "mongoose";
+var AuthTokenBlocklistSchema = new mongoose3.Schema(
+  {
+    jti: { type: String, required: true }
+  },
+  { collection: "token_blocklist", timestamps: true }
+);
+var AuthTokenBlocklistModel = mongoose3.model(
+  "AuthTokenBlocklist",
+  AuthTokenBlocklistSchema
+);
+
+// src/middleware/authentication/validation.ts
+var FORBIDDEN = 403;
+var UNAUTHORIZED = 401;
+async function jwtRequired(req, res, next) {
+  await validateJwt(req, res, next, JwtSecret);
+}
+async function jwtRefreshRequired(req, res, next) {
+  await 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 AuthTokenBlocklistModel.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 AuthUserModel.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.authUserPayload = 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 AuthTokenBlocklistModel.findOne({ jti });
+  } while (blocked != void 0);
+  const user = await AuthUserModel.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) {
+    res.sendStatus(FORBIDDEN2);
+    return;
+  }
+  identifier = identifier.toLowerCase();
+  let user = await AuthUserModel.findOne({ identifier });
+  if (user) {
+    res.sendStatus(BAD_REQUEST);
+    return;
+  }
+  res.locals.authUser = new AuthUserModel({
+    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) {
+    res.sendStatus(FORBIDDEN2);
+    return;
+  }
+  identifier = identifier.toLowerCase();
+  let user = await AuthUserModel.findOne({ identifier }).select("+secretHash");
+  if (!user || !user.secretHash) {
+    res.sendStatus(BAD_REQUEST);
+    return;
+  }
+  if (user.blockedSince) {
+    res.sendStatus(FORBIDDEN2);
+    return;
+  }
+  let isMatch = await bcrypt.compare(secret, user.secretHash);
+  if (!isMatch) {
+    res.sendStatus(BAD_REQUEST);
+    return;
+  }
+  let credentials = await generateCredentials(user);
+  if (!credentials) {
+    res.sendStatus(BAD_REQUEST);
+    return;
+  }
+  res.locals.credentials = credentials;
+  res.locals.authUser = user;
+  next();
+}
+async function authLogout(req, res, next) {
+  await jwtRefreshRequired(req, res, async () => {
+    let authUserPayload = res.locals.authUserPayload;
+    let user = await AuthUserModel.findOne({ identifier: authUserPayload.identifier }).select(
+      "+secretHash"
+    );
+    if (!user || !user.secretHash) {
+      res.sendStatus(BAD_REQUEST);
+      return;
+    }
+    const refreshToken = res.locals.token;
+    if (!refreshToken) {
+      res.sendStatus(BAD_REQUEST);
+      return;
+    }
+    const decoded = jwt2.decode(refreshToken);
+    const jti = decoded?.jti;
+    if (jti) {
+      const existingBlock = await AuthTokenBlocklistModel.findOne({ jti });
+      if (!existingBlock) {
+        await new AuthTokenBlocklistModel({ 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 AuthTokenBlocklistModel.findOne({ jti: accessTokenJti });
+        if (!existing) {
+          await new AuthTokenBlocklistModel({ jti: accessTokenJti }).save();
+        }
+      }
+    }
+    res.locals.authUser = user;
+    next();
+  });
+}
+async function authRefresh(req, res, next) {
+  await jwtRefreshRequired(req, res, async () => {
+    let authUserPayload = res.locals.authUserPayload;
+    let user = await AuthUserModel.findOne({ identifier: authUserPayload.identifier }).select(
+      "+secretHash"
+    );
+    if (!user || !user.secretHash) {
+      res.sendStatus(BAD_REQUEST);
+      return;
+    }
+    const refreshToken = res.locals.token;
+    if (!refreshToken) {
+      res.sendStatus(BAD_REQUEST);
+      return;
+    }
+    try {
+      const decoded = jwt2.decode(refreshToken);
+      const jti = decoded?.jti;
+      if (jti) {
+        const existingBlock = await AuthTokenBlocklistModel.findOne({ jti });
+        if (!existingBlock) {
+          await new AuthTokenBlocklistModel({ 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 AuthTokenBlocklistModel.findOne({
+            jti: accessTokenJti
+          });
+          if (!existing) {
+            await new AuthTokenBlocklistModel({ jti: accessTokenJti }).save();
+          }
+        }
+      }
+      const payload = jwt2.verify(refreshToken, JwtRefreshSecret);
+      let credentials = await generateCredentials(payload);
+      if (!credentials) {
+        res.sendStatus(BAD_REQUEST);
+        return;
+      }
+      res.locals.authUser = user;
+      res.locals.credentials = credentials;
+      next();
+    } catch (err) {
+      console.log("[WARN] refreshing JWT:", err);
+      res.sendStatus(BAD_REQUEST);
+      return;
+    }
+  });
+}
+
+// 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 FluentPatternHandler.
+   * @param execMiddleware - Optional array of middleware functions to be executed before the main query execution in the exec method.
+   */
+  constructor(execMiddleware = []) {
+    /**
+     * Array of middleware functions to be executed before the main query execution in the exec method. Each function receives the execution parameters and can modify them as needed.
+     */
+    this._execMiddlewareFunctions = [];
+    if (_FluentPatternHandler._singleton) {
+      throw new Error(
+        "FluentPatternHandler is a singleton class. Use FluentPatternHandler.getInstance() to access the instance."
+      );
+    }
+    this._execMiddlewareFunctions = execMiddleware;
+    _FluentPatternHandler._singleton = this;
+  }
+  /**
+   * Initializes the singleton instance of FluentPatternHandler with the provided options.
+   * @param execMiddleware - Optional array of middleware functions to be executed before the main query execution in the exec method.
+   * @returns Singleton instance of FluentPatternHandler.
+   */
+  static init(execMiddleware = []) {
+    if (_FluentPatternHandler._singleton != void 0) {
+      throw new Error("FluentPatternHandler is already initialized");
+    }
+    _FluentPatternHandler._singleton = new _FluentPatternHandler(execMiddleware);
+    return _FluentPatternHandler._singleton;
+  }
+  /**
+   * Returns the singleton instance of FluentPatternHandler.
+   * @returns Singleton instance of FluentPatternHandler.
+   */
+  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("[FluentPatternHandler] 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("[FluentPatternHandler] 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 } });
+      }
+    }
+  }
+  /**
+   * Generates filter fields for the given Mongoose model based on schema options.
+   * @param model - The Mongoose model.
+   * @returns Array of filter fields.
+   */
+  _getFilterFieldsForModel(model) {
+    let filterFields = [];
+    let schema = model.schema;
+    schema.eachPath((path2, type) => {
+      if (type?.options?.filter == true) {
+        filterFields.push(path2);
+      }
+    });
+    return filterFields;
+  }
+  /**
+   * 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 applied filters and returns the result.
+   * @param params Execution parameters including the query builder and request query.
+   * @returns
+   */
+  async exec(params) {
+    try {
+      if (this._execMiddlewareFunctions && this._execMiddlewareFunctions.length > 0) {
+        for (const func of this._execMiddlewareFunctions) {
+          await func(params);
+        }
+      }
+      const queryParams = this._parseFluentRequestQuery(params.req.query);
+      this._applyParameters(params.queryBuilder, queryParams);
+      const execConfig = this._buildExecutionConfig(queryParams);
+      return await params.queryBuilder.exec(execConfig);
+    } catch (err) {
+      console.error("[ERROR - FluentPatternHandler]", 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;
+}
+
+// bin/repl.ts
+import { start } from "node:repl";
+global.tsledge = src_exports;
+console.log("------------------------------------------");
+console.log("\u{1F4A1} TSledge scope is available with 'global.tsledge'");
+console.log(" (To exit, press Ctrl+C again or Ctrl+D or type .exit)");
+console.log("------------------------------------------");
+var session = start({
+  prompt: "tsledge > ",
+  useGlobal: true
+  // Wichtig, damit das globale 'tsledge' direkt erkannt wird
+});
+//# sourceMappingURL=repl.js.map