openloops 0.1.9 → 0.1.10

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.d.ts

@@ -0,0 +1,87 @@
+import { ObjectId } from 'mongodb';
+export declare class MongoRepository<T> {
+    private readonly database;
+    private readonly collection;
+    private readonly dbClient;
+    private readonly _where;
+    private readonly report;
+    constructor(props: {
+        database: string;
+        collection: string;
+        envvar?: string;
+    });
+    parseId(id: string | undefined): ObjectId | undefined;
+    cleanInput(value: string): string;
+    private clampLimit;
+    findOne({ where, select, options }: QueryParams<T>): Promise<T | null>;
+    findMany({ where, select, options }: QueryParams<T>): Promise<T[]>;
+    findAll({ where, select }: QueryParams<T>): Promise<T[]>;
+    createOne({ payload }: CommandParams<T>): Promise<ObjectId>;
+    createMany({ payload }: CommandParams<T>): Promise<CreateManyResponse>;
+    updateOne({ where, payload, options }: CommandParams<T>): Promise<T>;
+    updateMany({ where, payload }: CommandParams<T>): Promise<number>;
+    deleteOne({ where }: CommandParams<T>): Promise<number>;
+    deleteMany({ where }: CommandParams<T>): Promise<number>;
+    count({ where, options }: QueryParams<T>): Promise<number>;
+    aggregate(pipeline: PipelineStage[]): Promise<T[]>;
+    distinct(field: string, where?: Record<string, unknown>): Promise<T[]>;
+}
+export type PipelineStage = {
+    $addFields: Record<string, unknown>;
+} | {
+    $project: Record<string, unknown>;
+} | {
+    $lookup: Record<string, unknown>;
+} | {
+    $match: Record<string, unknown>;
+} | {
+    $facet: Record<string, unknown>;
+} | {
+    $group: Record<string, unknown>;
+} | {
+    $merge: Record<string, unknown>;
+} | {
+    $sort: Record<string, unknown>;
+} | {
+    $set: Record<string, unknown>;
+} | {
+    $sample: {
+        size: number;
+    };
+} | {
+    $unwind: string;
+} | {
+    $count: string;
+} | {
+    $limit: number;
+} | {
+    $skip: number;
+} | {
+    $out: string;
+};
+type CreateManyResponse = {
+    [key: number]: ObjectId;
+};
+export interface QueryParams<T> {
+    where?: Partial<T>;
+    select?: {
+        [K in keyof T]?: 1 | 0;
+    };
+    options?: QueryOptions;
+}
+export interface QueryOptions {
+    page?: number;
+    limit?: number;
+    offset?: number;
+    sortBy?: {
+        [key: string]: 1 | -1;
+    };
+    aggregate?: boolean;
+    includeDeleted?: boolean;
+}
+export interface CommandParams<T> {
+    where?: Partial<T>;
+    payload?: Partial<T> | Partial<T>[];
+    options?: Record<string, unknown>;
+}
+export {};

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
+});

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

@@ -0,0 +1,196 @@
+import "../../chunk-XRJFNASX.mjs";
+import { ObjectId } from "mongodb";
+import { reportError } from "@common/error";
+import { getMongoDBClient } from "./mongo-db.client";
+const DEFAULT_LIMIT = 10;
+class MongoRepository {
+  database;
+  collection;
+  dbClient;
+  _where = { deletedAt: null, archivedAt: null };
+  report = 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 = 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" && ObjectId.isValid(id) ? new 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;
+    }
+  }
+}
+export {
+  MongoRepository
+};

package/dist/common/utils/secret-manager.d.ts

@@ -0,0 +1,15 @@
+import 'dotenv/config';
+export declare class SecretManager {
+    private static instance;
+    private cache;
+    private cryptr;
+    static getInstance(): SecretManager;
+    static encrypt(value: string): string;
+    private constructor();
+    get(key: string): string;
+    private getEnvVar;
+    private decryptEnvVar;
+    private isStringEncrypted;
+    private logElapsed;
+}
+export declare const secretManager: SecretManager;

package/dist/common/utils/secret-manager.js

@@ -0,0 +1,105 @@
+"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 secret_manager_exports = {};
+__export(secret_manager_exports, {
+  SecretManager: () => SecretManager,
+  secretManager: () => secretManager
+});
+module.exports = __toCommonJS(secret_manager_exports);
+var import_config = require("dotenv/config");
+var import_cryptr = __toESM(require("cryptr"));
+var import_logger = require("@common/logger");
+class SecretManager {
+  static instance;
+  cache = /* @__PURE__ */ new Map();
+  cryptr;
+  static getInstance() {
+    if (!SecretManager.instance) {
+      SecretManager.instance = new SecretManager();
+    }
+    return SecretManager.instance;
+  }
+  static encrypt(value) {
+    if (!value) throw new Error("[Secret manager] Value to encrypt cannot be empty");
+    return `ENC:${SecretManager.getInstance().cryptr.encrypt(value)}`;
+  }
+  constructor() {
+    const secretKey = process.env.SECRET_MANAGER_KEY;
+    if (!secretKey) {
+      throw new Error("[Secret manager] SSUID environment variable is not set");
+    }
+    this.cryptr = new import_cryptr.default(secretKey, {
+      pbkdf2Iterations: 1e3,
+      saltLength: 16
+    });
+  }
+  get(key) {
+    const startTime = process.hrtime.bigint();
+    if (this.cache.has(key)) {
+      const decryptedValue2 = this.cache.get(key);
+      this.logElapsed(key, startTime, true);
+      return decryptedValue2;
+    }
+    const encryptedValue = this.getEnvVar(key);
+    const decryptedValue = this.decryptEnvVar(encryptedValue);
+    this.cache.set(key, decryptedValue);
+    this.logElapsed(key, startTime, false);
+    return decryptedValue;
+  }
+  getEnvVar(key) {
+    const value = process.env[key];
+    if (!value) throw new Error(`[Secret manager] Environment variable ${key} is not set`);
+    return value;
+  }
+  decryptEnvVar(encryptedValue) {
+    if (!encryptedValue) throw new Error("[Secret manager] Encrypted value cannot be empty");
+    if (!this.isStringEncrypted(encryptedValue)) {
+      import_logger.logger.debug("[Secret Manager] Value is not encrypted");
+      return encryptedValue;
+    }
+    const valueWithoutPrefix = encryptedValue.replace(/^ENC:/, "");
+    return this.cryptr.decrypt(valueWithoutPrefix);
+  }
+  isStringEncrypted(value) {
+    if (!value) return false;
+    return value.startsWith("ENC:");
+  }
+  logElapsed(key, startTime, cached) {
+    const endTime = process.hrtime.bigint();
+    const elapsedTimeInMs = Number(endTime - startTime) / 1e6;
+    const suffix = cached ? " (cached)" : "";
+    import_logger.logger.debug(`[Secret Manager] GET: ${key} | ${elapsedTimeInMs.toFixed(3)} ms${suffix}`);
+  }
+}
+const secretManager = SecretManager.getInstance();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SecretManager,
+  secretManager
+});