openloops 0.1.8 → 0.1.10

package/dist/common/helpers/sanitize-string.js

@@ -0,0 +1,45 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sanitize_string_exports = {};
+__export(sanitize_string_exports, {
+  sanitizeString: () => sanitizeString
+});
+module.exports = __toCommonJS(sanitize_string_exports);
+var import_sanitize_html = __toESM(require("sanitize-html"));
+function sanitizeString(input = "") {
+  if (!input) return void 0;
+  return (0, import_sanitize_html.default)(input, {
+    allowedTags: [],
+    allowedAttributes: {}
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sanitizeString
+});

package/dist/common/helpers/sanitize-string.mjs

@@ -0,0 +1,12 @@
+import "../../chunk-XRJFNASX.mjs";
+import sanitizeHtml from "sanitize-html";
+function sanitizeString(input = "") {
+  if (!input) return void 0;
+  return sanitizeHtml(input, {
+    allowedTags: [],
+    allowedAttributes: {}
+  });
+}
+export {
+  sanitizeString
+};

package/dist/common/logger/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var logger_exports = {};
+module.exports = __toCommonJS(logger_exports);
+__reExport(logger_exports, require("./pino"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./pino")
+});

package/dist/common/logger/index.mjs

@@ -0,0 +1 @@
+export * from "./pino";

package/dist/common/logger/pino.js

@@ -0,0 +1,70 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pino_exports = {};
+__export(pino_exports, {
+  Logger: () => Logger,
+  logger: () => logger
+});
+module.exports = __toCommonJS(pino_exports);
+var import_config = require("dotenv/config");
+var import_pino = __toESM(require("pino"));
+var import_pino_pretty = __toESM(require("pino-pretty"));
+const stream = (0, import_pino_pretty.default)({ colorize: true });
+class Logger {
+  IS_LOCAL = process.env.IS_LOCAL === "true" || process.env.NODE_ENV === "development";
+  logger = this.IS_LOCAL ? (0, import_pino.default)({ level: "debug" }, stream) : (0, import_pino.default)({ level: "info" });
+  log(level, obj, msg) {
+    if (typeof obj === "string") {
+      msg = obj;
+      obj = void 0;
+    }
+    this.logger[level](obj ?? {}, msg || "");
+  }
+  info(obj, msg) {
+    this.log("info", obj, msg);
+  }
+  warn(obj, msg) {
+    this.log("warn", obj, msg);
+  }
+  debug(obj, msg) {
+    this.log("debug", obj, msg);
+  }
+  error(obj, msg) {
+    this.log("error", obj, msg);
+  }
+  fatal(obj, msg) {
+    this.log("fatal", obj, msg);
+  }
+}
+const logger = new Logger();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Logger,
+  logger
+});

package/dist/common/logger/pino.mjs

@@ -0,0 +1,36 @@
+import "../../chunk-XRJFNASX.mjs";
+import "dotenv/config";
+import pino from "pino";
+import pretty from "pino-pretty";
+const stream = pretty({ colorize: true });
+class Logger {
+  IS_LOCAL = process.env.IS_LOCAL === "true" || process.env.NODE_ENV === "development";
+  logger = this.IS_LOCAL ? pino({ level: "debug" }, stream) : pino({ level: "info" });
+  log(level, obj, msg) {
+    if (typeof obj === "string") {
+      msg = obj;
+      obj = void 0;
+    }
+    this.logger[level](obj ?? {}, msg || "");
+  }
+  info(obj, msg) {
+    this.log("info", obj, msg);
+  }
+  warn(obj, msg) {
+    this.log("warn", obj, msg);
+  }
+  debug(obj, msg) {
+    this.log("debug", obj, msg);
+  }
+  error(obj, msg) {
+    this.log("error", obj, msg);
+  }
+  fatal(obj, msg) {
+    this.log("fatal", obj, msg);
+  }
+}
+const logger = new Logger();
+export {
+  Logger,
+  logger
+};

package/dist/common/repositories/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var repositories_exports = {};
+module.exports = __toCommonJS(repositories_exports);
+__reExport(repositories_exports, require("./mongo-db.repository"), module.exports);
+__reExport(repositories_exports, require("./mongo-db.client"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./mongo-db.repository"),
+  ...require("./mongo-db.client")
+});

package/dist/common/repositories/index.mjs

@@ -0,0 +1,2 @@
+export * from "./mongo-db.repository";
+export * from "./mongo-db.client";

package/dist/common/repositories/mongo-db.client.js

@@ -0,0 +1,79 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mongo_db_client_exports = {};
+__export(mongo_db_client_exports, {
+  MongoClient: () => MongoClient,
+  getMongoDBClient: () => getMongoDBClient
+});
+module.exports = __toCommonJS(mongo_db_client_exports);
+var import_mongodb = require("mongodb");
+var import_secret_manager = require("@common/utils/secret-manager");
+var import_logger = require("@common/logger");
+var import_error = require("@common/error");
+class MongoClient {
+  client;
+  logger = import_logger.logger;
+  isConnected = false;
+  constructor(uri, options) {
+    if (!uri) throw new Error("[Mongo Client]: uri parameter is required");
+    this.client = new import_mongodb.MongoClient(uri, {
+      ...options,
+      connectTimeoutMS: 5e3,
+      serverSelectionTimeoutMS: 5e3
+    });
+    this.logger.info("[Mongo Client] Client initialized");
+  }
+  async connect() {
+    if (!this.client) throw new Error("[Mongo Client]: Client is not initialized");
+    if (!this.isConnected) {
+      await this.client.connect();
+      this.isConnected = true;
+      this.logger.info("[Mongo Client]: Connected to MongoDB");
+    }
+  }
+  async close(force) {
+    await this.client.close(force || false);
+    this.isConnected = false;
+  }
+  async db(dbName, options) {
+    try {
+      await this.connect();
+    } catch (error) {
+      this.logger.error("[Mongo Client]: Error connecting to MongoDB");
+      await (0, import_error.reportError)(`Error connecting to MongoDB: ${error.message}`, { error });
+      throw error;
+    }
+    return this.client.db(dbName, options);
+  }
+}
+const mongoDBClients = /* @__PURE__ */ new Map();
+function getMongoDBClient(envVarName = "OPENLOOPS_DB_URI") {
+  if (!mongoDBClients.has(envVarName)) {
+    const connString = import_secret_manager.secretManager.get(envVarName);
+    if (connString) {
+      mongoDBClients.set(envVarName, new MongoClient(connString, {}));
+    }
+  }
+  return mongoDBClients.get(envVarName);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MongoClient,
+  getMongoDBClient
+});

package/dist/common/repositories/mongo-db.client.mjs

@@ -0,0 +1,57 @@
+import "../../chunk-XRJFNASX.mjs";
+import {
+  MongoClient as BaseMongoCLient
+} from "mongodb";
+import { secretManager } from "@common/utils/secret-manager";
+import { logger } from "@common/logger";
+import { reportError } from "@common/error";
+class MongoClient {
+  client;
+  logger = logger;
+  isConnected = false;
+  constructor(uri, options) {
+    if (!uri) throw new Error("[Mongo Client]: uri parameter is required");
+    this.client = new BaseMongoCLient(uri, {
+      ...options,
+      connectTimeoutMS: 5e3,
+      serverSelectionTimeoutMS: 5e3
+    });
+    this.logger.info("[Mongo Client] Client initialized");
+  }
+  async connect() {
+    if (!this.client) throw new Error("[Mongo Client]: Client is not initialized");
+    if (!this.isConnected) {
+      await this.client.connect();
+      this.isConnected = true;
+      this.logger.info("[Mongo Client]: Connected to MongoDB");
+    }
+  }
+  async close(force) {
+    await this.client.close(force || false);
+    this.isConnected = false;
+  }
+  async db(dbName, options) {
+    try {
+      await this.connect();
+    } catch (error) {
+      this.logger.error("[Mongo Client]: Error connecting to MongoDB");
+      await reportError(`Error connecting to MongoDB: ${error.message}`, { error });
+      throw error;
+    }
+    return this.client.db(dbName, options);
+  }
+}
+const mongoDBClients = /* @__PURE__ */ new Map();
+function getMongoDBClient(envVarName = "OPENLOOPS_DB_URI") {
+  if (!mongoDBClients.has(envVarName)) {
+    const connString = secretManager.get(envVarName);
+    if (connString) {
+      mongoDBClients.set(envVarName, new MongoClient(connString, {}));
+    }
+  }
+  return mongoDBClients.get(envVarName);
+}
+export {
+  MongoClient,
+  getMongoDBClient
+};

package/dist/common/repositories/mongo-db.repository.js

@@ -0,0 +1,219 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mongo_db_repository_exports = {};
+__export(mongo_db_repository_exports, {
+  MongoRepository: () => MongoRepository
+});
+module.exports = __toCommonJS(mongo_db_repository_exports);
+var import_mongodb = require("mongodb");
+var import_error = require("@common/error");
+var import_mongo_db = require("./mongo-db.client");
+const DEFAULT_LIMIT = 10;
+class MongoRepository {
+  database;
+  collection;
+  dbClient;
+  _where = { deletedAt: null, archivedAt: null };
+  report = import_error.reportError;
+  constructor(props) {
+    const { database, collection, envvar } = props || {};
+    if (!database) throw new Error("[Mongo Repository] Database name is required");
+    if (!collection) throw new Error("[Mongo Repository] Collection name is required");
+    this.dbClient = (0, import_mongo_db.getMongoDBClient)(envvar);
+    if (!this.dbClient) throw new Error("[Mongo Repository] Database client not found");
+    this.database = database;
+    this.collection = collection;
+  }
+  parseId(id) {
+    return typeof id === "string" && import_mongodb.ObjectId.isValid(id) ? new import_mongodb.ObjectId(id) : void 0;
+  }
+  cleanInput(value) {
+    return value?.replace(/[{}[\]()\/\\]/g, "");
+  }
+  clampLimit(limit) {
+    const n = Number(limit);
+    return !Number.isFinite(n) || n <= 0 ? DEFAULT_LIMIT : n;
+  }
+  async findOne({ where, select, options }) {
+    try {
+      const db = await this.dbClient.db(this.database);
+      const collection = db.collection(this.collection);
+      const result = await collection.findOne(
+        { ...where, ...this._where },
+        {
+          ...select ? { projection: select } : {},
+          ...options
+        }
+      );
+      return result;
+    } catch (error) {
+      await this.report(error);
+      throw error;
+    }
+  }
+  async findMany({ where, select, options }) {
+    try {
+      const db = await this.dbClient.db(this.database);
+      const collection = db.collection(this.collection);
+      const { page = 1, limit = 10 } = options || {};
+      const _limit = this.clampLimit(limit);
+      const _skip = +page > 0 ? (+page - 1) * _limit : 0;
+      const result = await collection.find({ ...where, ...this._where }, { projection: select }).sort(options?.sortBy || { _id: -1 }).skip(_skip).limit(_limit).toArray();
+      return result;
+    } catch (error) {
+      await this.report(error);
+      throw error;
+    }
+  }
+  async findAll({ where, select }) {
+    try {
+      const db = await this.dbClient.db(this.database);
+      const collection = db.collection(this.collection);
+      const result = await collection.find({ ...where, ...this._where }, { projection: select }).toArray();
+      return result;
+    } catch (error) {
+      await this.report(error);
+      throw error;
+    }
+  }
+  async createOne({ payload }) {
+    if (!payload || Object.keys(payload).length === 0) throw new Error("[Mongo Repository] Payload is required for createOne operation");
+    try {
+      const db = await this.dbClient.db(this.database);
+      const collection = db.collection(this.collection);
+      const { insertedId } = await collection.insertOne({ ...payload, __v: 1 });
+      return insertedId;
+    } catch (error) {
+      await this.report(error);
+      throw error;
+    }
+  }
+  async createMany({ payload }) {
+    try {
+      const db = await this.dbClient.db(this.database);
+      const collection = db.collection(this.collection);
+      const { insertedIds } = await collection.insertMany(payload);
+      return insertedIds;
+    } catch (error) {
+      await this.report(error);
+      throw error;
+    }
+  }
+  async updateOne({ where, payload, options }) {
+    if (!where || Object.keys(where).length === 0) throw new Error("[Mongo Repository] Where is required for updateOne operation");
+    if (!payload || Object.keys(payload).length === 0) throw new Error("[Mongo Repository] Payload is required for updateOne operation");
+    try {
+      const db = await this.dbClient.db(this.database);
+      const collection = db.collection(this.collection);
+      const { _id, __v, createdAt, createdBy, toUnset, ...toSet } = payload;
+      const __payload = {
+        ...toSet ? { $set: toSet } : {},
+        ...toUnset ? { $unset: toUnset } : {}
+      };
+      const result = await collection.findOneAndUpdate(
+        { ...where, ...this._where },
+        {
+          $inc: { __v: 1 },
+          ...__payload
+        },
+        {
+          returnDocument: "after"
+        }
+      );
+      return result;
+    } catch (error) {
+      await this.report(error);
+      throw error;
+    }
+  }
+  async updateMany({ where, payload }) {
+    try {
+      const db = await this.dbClient.db(this.database);
+      const collection = db.collection(this.collection);
+      const result = await collection.updateMany(
+        { ...where, ...this._where },
+        { $set: payload }
+      );
+      const countUpdated = result.modifiedCount;
+      return countUpdated;
+    } catch (error) {
+      await this.report(error);
+      throw error;
+    }
+  }
+  async deleteOne({ where }) {
+    try {
+      const db = await this.dbClient.db(this.database);
+      const collection = db.collection(this.collection);
+      const { deletedCount } = await collection.deleteOne({ ...where });
+      return deletedCount;
+    } catch (error) {
+      await this.report(error);
+      throw error;
+    }
+  }
+  async deleteMany({ where }) {
+    try {
+      const db = await this.dbClient.db(this.database);
+      const collection = db.collection(this.collection);
+      const { deletedCount } = await collection.deleteMany({ ...where });
+      return deletedCount;
+    } catch (error) {
+      await this.report(error);
+      throw error;
+    }
+  }
+  async count({ where, options }) {
+    try {
+      const db = await this.dbClient.db(this.database);
+      const collection = db.collection(this.collection);
+      const result = await collection.countDocuments({ ...where, ...options?.includeDeleted ? {} : this._where });
+      return result;
+    } catch (error) {
+      await this.report(error);
+      throw error;
+    }
+  }
+  async aggregate(pipeline) {
+    try {
+      const db = await this.dbClient.db(this.database);
+      const collection = db.collection(this.collection);
+      const result = await collection.aggregate(pipeline).toArray();
+      return result;
+    } catch (error) {
+      await this.report(error);
+      throw error;
+    }
+  }
+  async distinct(field, where) {
+    try {
+      const db = await this.dbClient.db(this.database);
+      const collection = db.collection(this.collection);
+      const result = await collection.distinct(field, { ...where, ...this._where });
+      return result;
+    } catch (error) {
+      await this.report(error);
+      throw error;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MongoRepository
+});