@gustavo-valsechi/node 1.0.3 → 1.0.5

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 export { databaseInit } from './src/database/index.mjs';
 export { apiRouter, mainRouter } from './src/router/index.mjs';
 export { app, serverInit } from './src/server/index.mjs';
-export { responseWrapper } from './src/tools/index.mjs';
+export { OPERATORS, converter, existsOperator, moduler, paginate, refactorWhere, responseWrapper } from './src/tools/index.mjs';
 import 'typeorm';
 import 'fastify';
 import 'http';

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { databaseInit } from './src/database/index.js';
 export { apiRouter, mainRouter } from './src/router/index.js';
 export { app, serverInit } from './src/server/index.js';
-export { responseWrapper } from './src/tools/index.js';
+export { OPERATORS, converter, existsOperator, moduler, paginate, refactorWhere, responseWrapper } from './src/tools/index.js';
 import 'typeorm';
 import 'fastify';
 import 'http';

package/dist/index.js

@@ -30,10 +30,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // index.ts
 var index_exports = {};
 __export(index_exports, {
+  OPERATORS: () => OPERATORS,
   apiRouter: () => apiRouter,
   app: () => app,
+  converter: () => converter,
   databaseInit: () => databaseInit,
+  existsOperator: () => existsOperator,
   mainRouter: () => mainRouter,
+  moduler: () => moduler,
+  paginate: () => paginate,
+  refactorWhere: () => refactorWhere,
   responseWrapper: () => responseWrapper,
   serverInit: () => serverInit
 });
@@ -70,7 +76,7 @@ var databaseInit = (entities) => {
     applicationName: (0, import_os.hostname)(),
     entities
   });
-  DB.initialize().then(() => console.log("Data Source has been initialized!")).catch((err) => console.error("Error during Data Source initialization", err));
+  DB.initialize().then(() => console.log("\u{1F680} Data Source has been initialized!")).catch((err) => console.error("\u{1F534} Error during Data Source initialization", err));
   return DB;
 };
 
@@ -89,6 +95,122 @@ var responseWrapper = async (res, promise) => {
   });
 };
 
+// src/tools/operators.ts
+var import_typeorm2 = require("typeorm");
+var import_lodash = __toESM(require("lodash"));
+var OPERATORS = {
+  $in: (value) => (0, import_typeorm2.In)(value),
+  $and: (value) => (0, import_typeorm2.And)(value),
+  $notIn: (value) => (0, import_typeorm2.Not)((0, import_typeorm2.In)(value)),
+  $like: (value) => (0, import_typeorm2.Like)(value),
+  $notLike: (value) => (0, import_typeorm2.Not)((0, import_typeorm2.Like)(value)),
+  $gt: (value) => (0, import_typeorm2.MoreThan)(value),
+  $gte: (value) => (0, import_typeorm2.MoreThanOrEqual)(value),
+  $lt: (value) => (0, import_typeorm2.LessThan)(value),
+  $lte: (value) => (0, import_typeorm2.LessThanOrEqual)(value),
+  $between: ([from, to]) => (0, import_typeorm2.Between)(from, to),
+  $not: (value) => (0, import_typeorm2.Not)(value),
+  $ne: (value) => (0, import_typeorm2.Not)(value),
+  $raw: (value) => (0, import_typeorm2.Raw)((alias) => import_lodash.default.replace(value, "ALIAS", alias))
+};
+var existsOperator = (value) => {
+  let includeOp = false;
+  for (const op in OPERATORS) {
+    if (includeOp) continue;
+    includeOp = import_lodash.default.includes(JSON.stringify(value), op);
+  }
+  return includeOp;
+};
+var converter = (operator) => {
+  operator = import_lodash.default.isObject(operator) ? operator : JSON.parse(operator || "{}");
+  let convertion = operator;
+  for (const op in OPERATORS) {
+    if (!operator[op] && operator[op] !== 0) continue;
+    if (import_lodash.default.isObject(operator[op]) && import_lodash.default.isArray(operator[op])) {
+      import_lodash.default.forEach(operator[op], (condition, index) => {
+        if (!existsOperator(condition)) return;
+        for (const opSecondary in OPERATORS) {
+          if (!condition[opSecondary] && condition[opSecondary] !== 0) continue;
+          operator[op][index] = OPERATORS[opSecondary](condition[opSecondary]);
+        }
+      });
+    }
+    convertion = OPERATORS[op](operator[op]);
+  }
+  return convertion;
+};
+var refactorWhere = (where) => {
+  for (const key in where) {
+    let includeOp = existsOperator(where[key]);
+    if (includeOp) {
+      where[key] = converter(where[key]);
+      if (import_lodash.default.isObject(where[key]) && !import_lodash.default.isArray(where[key])) {
+        for (const keyObject in where[key]) {
+          includeOp = existsOperator(where[key][keyObject]);
+          if (!includeOp) continue;
+          where[key][keyObject] = converter(where[key][keyObject]);
+        }
+      }
+      if (import_lodash.default.isObject(where[key]) && import_lodash.default.isArray(where[key])) {
+        import_lodash.default.forEach(where[key], (condition, index) => {
+          includeOp = existsOperator(condition);
+          if (includeOp) {
+            condition = converter(condition);
+            if (import_lodash.default.isObject(condition) && !import_lodash.default.isArray(condition)) {
+              for (const keyObject in condition) {
+                includeOp = existsOperator(condition[keyObject]);
+                if (!includeOp) continue;
+                condition[keyObject] = converter(condition[keyObject]);
+              }
+            }
+          }
+          where[key][index] = condition;
+        });
+      }
+    }
+  }
+  return where;
+};
+
+// src/tools/paginate.ts
+var import_lodash2 = __toESM(require("lodash"));
+var parse = (json) => {
+  if (!json) return;
+  if (import_lodash2.default.isString(json)) return JSON.parse(json);
+  return json;
+};
+var paginate = async (repository, options) => {
+  let where = parse(options.filters);
+  if (where) where = refactorWhere(where);
+  const [data, count] = await repository.findAndCount({
+    select: options.fields,
+    relations: options.relations,
+    where,
+    order: parse(options.order),
+    take: options.limit,
+    skip: Number(options.page) * (Number(options.limit) || 0) || 0
+  });
+  return {
+    totalPage: Math.ceil(count / options.limit),
+    total: count,
+    content: data
+  };
+};
+
+// src/tools/moduler.ts
+var import_path = __toESM(require("path"));
+var import_fs = __toESM(require("fs"));
+var moduler = () => {
+  let content = {};
+  import_fs.default.readdirSync(__dirname).forEach((file) => {
+    if (file === "index.ts" || !file.endsWith(".ts")) return;
+    const filePath = import_path.default.join(__dirname, file);
+    const module2 = require(filePath);
+    content = { ...content, ...module2 };
+  });
+  return content;
+};
+
 // src/router/health.ts
 var healthRouter = (router, options, done) => {
   router.get("/", async (req, res) => {
@@ -135,20 +257,20 @@ var serverInit = (appConfig) => {
   };
   app.listen(listenOptions, (err, address) => {
     if (err) {
-      console.error("Error in server initialization!", err);
+      console.error("\u{1F534} Error in server initialization!", err);
       process.exit(1);
     }
-    console.log(`Server has been started in ${address}...`);
+    console.log(`\u{1F680} Server has been started in ${address}...`);
   });
   return app;
 };
 
 // src/router/api.ts
-var import_lodash = __toESM(require("lodash"));
+var import_lodash3 = __toESM(require("lodash"));
 var apiRouter = (registers) => {
   const apiPrefix = "api";
   app.register((router, options, done) => {
-    import_lodash.default.forEach(registers, (register, prefix) => {
+    import_lodash3.default.forEach(registers, (register, prefix) => {
       router.register(register, { prefix: `${apiPrefix}/${prefix}` });
     });
     done();
@@ -162,10 +284,16 @@ var mainRouter = (router, options, done) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  OPERATORS,
   apiRouter,
   app,
+  converter,
   databaseInit,
+  existsOperator,
   mainRouter,
+  moduler,
+  paginate,
+  refactorWhere,
   responseWrapper,
   serverInit
 });

package/dist/index.mjs

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/database/index.ts
 import "dotenv/config";
 import { hostname } from "os";
@@ -29,7 +36,7 @@ var databaseInit = (entities) => {
     applicationName: hostname(),
     entities
   });
-  DB.initialize().then(() => console.log("Data Source has been initialized!")).catch((err) => console.error("Error during Data Source initialization", err));
+  DB.initialize().then(() => console.log("\u{1F680} Data Source has been initialized!")).catch((err) => console.error("\u{1F534} Error during Data Source initialization", err));
   return DB;
 };
 
@@ -48,6 +55,133 @@ var responseWrapper = async (res, promise) => {
   });
 };
 
+// src/tools/operators.ts
+import {
+  Like,
+  MoreThan,
+  MoreThanOrEqual,
+  In,
+  Not,
+  LessThan,
+  Between,
+  Raw,
+  And,
+  LessThanOrEqual
+} from "typeorm";
+import _ from "lodash";
+var OPERATORS = {
+  $in: (value) => In(value),
+  $and: (value) => And(value),
+  $notIn: (value) => Not(In(value)),
+  $like: (value) => Like(value),
+  $notLike: (value) => Not(Like(value)),
+  $gt: (value) => MoreThan(value),
+  $gte: (value) => MoreThanOrEqual(value),
+  $lt: (value) => LessThan(value),
+  $lte: (value) => LessThanOrEqual(value),
+  $between: ([from, to]) => Between(from, to),
+  $not: (value) => Not(value),
+  $ne: (value) => Not(value),
+  $raw: (value) => Raw((alias) => _.replace(value, "ALIAS", alias))
+};
+var existsOperator = (value) => {
+  let includeOp = false;
+  for (const op in OPERATORS) {
+    if (includeOp) continue;
+    includeOp = _.includes(JSON.stringify(value), op);
+  }
+  return includeOp;
+};
+var converter = (operator) => {
+  operator = _.isObject(operator) ? operator : JSON.parse(operator || "{}");
+  let convertion = operator;
+  for (const op in OPERATORS) {
+    if (!operator[op] && operator[op] !== 0) continue;
+    if (_.isObject(operator[op]) && _.isArray(operator[op])) {
+      _.forEach(operator[op], (condition, index) => {
+        if (!existsOperator(condition)) return;
+        for (const opSecondary in OPERATORS) {
+          if (!condition[opSecondary] && condition[opSecondary] !== 0) continue;
+          operator[op][index] = OPERATORS[opSecondary](condition[opSecondary]);
+        }
+      });
+    }
+    convertion = OPERATORS[op](operator[op]);
+  }
+  return convertion;
+};
+var refactorWhere = (where) => {
+  for (const key in where) {
+    let includeOp = existsOperator(where[key]);
+    if (includeOp) {
+      where[key] = converter(where[key]);
+      if (_.isObject(where[key]) && !_.isArray(where[key])) {
+        for (const keyObject in where[key]) {
+          includeOp = existsOperator(where[key][keyObject]);
+          if (!includeOp) continue;
+          where[key][keyObject] = converter(where[key][keyObject]);
+        }
+      }
+      if (_.isObject(where[key]) && _.isArray(where[key])) {
+        _.forEach(where[key], (condition, index) => {
+          includeOp = existsOperator(condition);
+          if (includeOp) {
+            condition = converter(condition);
+            if (_.isObject(condition) && !_.isArray(condition)) {
+              for (const keyObject in condition) {
+                includeOp = existsOperator(condition[keyObject]);
+                if (!includeOp) continue;
+                condition[keyObject] = converter(condition[keyObject]);
+              }
+            }
+          }
+          where[key][index] = condition;
+        });
+      }
+    }
+  }
+  return where;
+};
+
+// src/tools/paginate.ts
+import _2 from "lodash";
+var parse = (json) => {
+  if (!json) return;
+  if (_2.isString(json)) return JSON.parse(json);
+  return json;
+};
+var paginate = async (repository, options) => {
+  let where = parse(options.filters);
+  if (where) where = refactorWhere(where);
+  const [data, count] = await repository.findAndCount({
+    select: options.fields,
+    relations: options.relations,
+    where,
+    order: parse(options.order),
+    take: options.limit,
+    skip: Number(options.page) * (Number(options.limit) || 0) || 0
+  });
+  return {
+    totalPage: Math.ceil(count / options.limit),
+    total: count,
+    content: data
+  };
+};
+
+// src/tools/moduler.ts
+import path from "path";
+import fs from "fs";
+var moduler = () => {
+  let content = {};
+  fs.readdirSync(__dirname).forEach((file) => {
+    if (file === "index.ts" || !file.endsWith(".ts")) return;
+    const filePath = path.join(__dirname, file);
+    const module = __require(filePath);
+    content = { ...content, ...module };
+  });
+  return content;
+};
+
 // src/router/health.ts
 var healthRouter = (router, options, done) => {
   router.get("/", async (req, res) => {
@@ -94,20 +228,20 @@ var serverInit = (appConfig) => {
   };
   app.listen(listenOptions, (err, address) => {
     if (err) {
-      console.error("Error in server initialization!", err);
+      console.error("\u{1F534} Error in server initialization!", err);
       process.exit(1);
     }
-    console.log(`Server has been started in ${address}...`);
+    console.log(`\u{1F680} Server has been started in ${address}...`);
   });
   return app;
 };
 
 // src/router/api.ts
-import _ from "lodash";
+import _3 from "lodash";
 var apiRouter = (registers) => {
   const apiPrefix = "api";
   app.register((router, options, done) => {
-    _.forEach(registers, (register, prefix) => {
+    _3.forEach(registers, (register, prefix) => {
       router.register(register, { prefix: `${apiPrefix}/${prefix}` });
     });
     done();
@@ -120,10 +254,16 @@ var mainRouter = (router, options, done) => {
   done();
 };
 export {
+  OPERATORS,
   apiRouter,
   app,
+  converter,
   databaseInit,
+  existsOperator,
   mainRouter,
+  moduler,
+  paginate,
+  refactorWhere,
   responseWrapper,
   serverInit
 };

package/dist/src/database/index.js

@@ -53,7 +53,7 @@ var databaseInit = (entities) => {
     applicationName: (0, import_os.hostname)(),
     entities
   });
-  DB.initialize().then(() => console.log("Data Source has been initialized!")).catch((err) => console.error("Error during Data Source initialization", err));
+  DB.initialize().then(() => console.log("\u{1F680} Data Source has been initialized!")).catch((err) => console.error("\u{1F534} Error during Data Source initialization", err));
   return DB;
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/src/database/index.mjs

@@ -29,7 +29,7 @@ var databaseInit = (entities) => {
     applicationName: hostname(),
     entities
   });
-  DB.initialize().then(() => console.log("Data Source has been initialized!")).catch((err) => console.error("Error during Data Source initialization", err));
+  DB.initialize().then(() => console.log("\u{1F680} Data Source has been initialized!")).catch((err) => console.error("\u{1F534} Error during Data Source initialization", err));
   return DB;
 };
 export {

package/dist/src/router/index.js

@@ -50,6 +50,13 @@ var responseWrapper = async (res, promise) => {
   });
 };
 
+// src/tools/operators.ts
+var import_typeorm = require("typeorm");
+var import_lodash = __toESM(require("lodash"));
+
+// src/tools/paginate.ts
+var import_lodash2 = __toESM(require("lodash"));
+
 // src/router/health.ts
 var healthRouter = (router, options, done) => {
   router.get("/", async (req, res) => {
@@ -69,11 +76,11 @@ var import_fastify_plugin = __toESM(require("fastify-plugin"));
 var app = (0, import_fastify.default)();
 
 // src/router/api.ts
-var import_lodash = __toESM(require("lodash"));
+var import_lodash3 = __toESM(require("lodash"));
 var apiRouter = (registers) => {
   const apiPrefix = "api";
   app.register((router, options, done) => {
-    import_lodash.default.forEach(registers, (register, prefix) => {
+    import_lodash3.default.forEach(registers, (register, prefix) => {
       router.register(register, { prefix: `${apiPrefix}/${prefix}` });
     });
     done();

package/dist/src/router/index.mjs

@@ -13,6 +13,24 @@ var responseWrapper = async (res, promise) => {
   });
 };
 
+// src/tools/operators.ts
+import {
+  Like,
+  MoreThan,
+  MoreThanOrEqual,
+  In,
+  Not,
+  LessThan,
+  Between,
+  Raw,
+  And,
+  LessThanOrEqual
+} from "typeorm";
+import _ from "lodash";
+
+// src/tools/paginate.ts
+import _2 from "lodash";
+
 // src/router/health.ts
 var healthRouter = (router, options, done) => {
   router.get("/", async (req, res) => {
@@ -32,11 +50,11 @@ import fp from "fastify-plugin";
 var app = fastify();
 
 // src/router/api.ts
-import _ from "lodash";
+import _3 from "lodash";
 var apiRouter = (registers) => {
   const apiPrefix = "api";
   app.register((router, options, done) => {
-    _.forEach(registers, (register, prefix) => {
+    _3.forEach(registers, (register, prefix) => {
       router.register(register, { prefix: `${apiPrefix}/${prefix}` });
     });
     done();

package/dist/src/server/index.js

@@ -51,6 +51,13 @@ var responseWrapper = async (res, promise) => {
   });
 };
 
+// src/tools/operators.ts
+var import_typeorm = require("typeorm");
+var import_lodash = __toESM(require("lodash"));
+
+// src/tools/paginate.ts
+var import_lodash2 = __toESM(require("lodash"));
+
 // src/router/health.ts
 var healthRouter = (router, options, done) => {
   router.get("/", async (req, res) => {
@@ -65,7 +72,7 @@ var healthRouter = (router, options, done) => {
 };
 
 // src/router/api.ts
-var import_lodash = __toESM(require("lodash"));
+var import_lodash3 = __toESM(require("lodash"));
 
 // src/router/index.ts
 var mainRouter = (router, options, done) => {
@@ -105,10 +112,10 @@ var serverInit = (appConfig) => {
   };
   app.listen(listenOptions, (err, address) => {
     if (err) {
-      console.error("Error in server initialization!", err);
+      console.error("\u{1F534} Error in server initialization!", err);
       process.exit(1);
     }
-    console.log(`Server has been started in ${address}...`);
+    console.log(`\u{1F680} Server has been started in ${address}...`);
   });
   return app;
 };

package/dist/src/server/index.mjs

@@ -16,6 +16,24 @@ var responseWrapper = async (res, promise) => {
   });
 };
 
+// src/tools/operators.ts
+import {
+  Like,
+  MoreThan,
+  MoreThanOrEqual,
+  In,
+  Not,
+  LessThan,
+  Between,
+  Raw,
+  And,
+  LessThanOrEqual
+} from "typeorm";
+import _ from "lodash";
+
+// src/tools/paginate.ts
+import _2 from "lodash";
+
 // src/router/health.ts
 var healthRouter = (router, options, done) => {
   router.get("/", async (req, res) => {
@@ -30,7 +48,7 @@ var healthRouter = (router, options, done) => {
 };
 
 // src/router/api.ts
-import _ from "lodash";
+import _3 from "lodash";
 
 // src/router/index.ts
 var mainRouter = (router, options, done) => {
@@ -70,10 +88,10 @@ var serverInit = (appConfig) => {
   };
   app.listen(listenOptions, (err, address) => {
     if (err) {
-      console.error("Error in server initialization!", err);
+      console.error("\u{1F534} Error in server initialization!", err);
       process.exit(1);
     }
-    console.log(`Server has been started in ${address}...`);
+    console.log(`\u{1F680} Server has been started in ${address}...`);
   });
   return app;
 };

package/dist/src/tools/index.d.mts

@@ -2,4 +2,28 @@ import { FastifyReply } from 'fastify';
 
 declare const responseWrapper: (res: FastifyReply, promise: Promise<any>) => Promise<void>;
 
-export { responseWrapper };
+declare const OPERATORS: any;
+declare const existsOperator: (value: any) => boolean;
+declare const converter: (operator: any) => any;
+declare const refactorWhere: (where: any) => any;
+
+declare const paginate: (repository: any, options: {
+    fields: Array<string>;
+    relations: Array<string>;
+    filters: string | {
+        [field: string]: any;
+    };
+    order: string | {
+        [field: string]: "asc" | "desc";
+    };
+    limit: number;
+    page: number;
+}) => Promise<{
+    totalPage: number;
+    total: any;
+    content: any;
+}>;
+
+declare const moduler: () => Record<string, any>;
+
+export { OPERATORS, converter, existsOperator, moduler, paginate, refactorWhere, responseWrapper };

package/dist/src/tools/index.d.ts

@@ -2,4 +2,28 @@ import { FastifyReply } from 'fastify';
 
 declare const responseWrapper: (res: FastifyReply, promise: Promise<any>) => Promise<void>;
 
-export { responseWrapper };
+declare const OPERATORS: any;
+declare const existsOperator: (value: any) => boolean;
+declare const converter: (operator: any) => any;
+declare const refactorWhere: (where: any) => any;
+
+declare const paginate: (repository: any, options: {
+    fields: Array<string>;
+    relations: Array<string>;
+    filters: string | {
+        [field: string]: any;
+    };
+    order: string | {
+        [field: string]: "asc" | "desc";
+    };
+    limit: number;
+    page: number;
+}) => Promise<{
+    totalPage: number;
+    total: any;
+    content: any;
+}>;
+
+declare const moduler: () => Record<string, any>;
+
+export { OPERATORS, converter, existsOperator, moduler, paginate, refactorWhere, responseWrapper };

package/dist/src/tools/index.js

@@ -1,7 +1,9 @@
 "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)
@@ -15,11 +17,25 @@ var __copyProps = (to, from, except, desc) => {
   }
   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);
 
 // src/tools/index.ts
 var tools_exports = {};
 __export(tools_exports, {
+  OPERATORS: () => OPERATORS,
+  converter: () => converter,
+  existsOperator: () => existsOperator,
+  moduler: () => moduler,
+  paginate: () => paginate,
+  refactorWhere: () => refactorWhere,
   responseWrapper: () => responseWrapper
 });
 module.exports = __toCommonJS(tools_exports);
@@ -38,7 +54,129 @@ var responseWrapper = async (res, promise) => {
     return res.status(status).send({ message: err.message, type: err.type, code: err.code });
   });
 };
+
+// src/tools/operators.ts
+var import_typeorm = require("typeorm");
+var import_lodash = __toESM(require("lodash"));
+var OPERATORS = {
+  $in: (value) => (0, import_typeorm.In)(value),
+  $and: (value) => (0, import_typeorm.And)(value),
+  $notIn: (value) => (0, import_typeorm.Not)((0, import_typeorm.In)(value)),
+  $like: (value) => (0, import_typeorm.Like)(value),
+  $notLike: (value) => (0, import_typeorm.Not)((0, import_typeorm.Like)(value)),
+  $gt: (value) => (0, import_typeorm.MoreThan)(value),
+  $gte: (value) => (0, import_typeorm.MoreThanOrEqual)(value),
+  $lt: (value) => (0, import_typeorm.LessThan)(value),
+  $lte: (value) => (0, import_typeorm.LessThanOrEqual)(value),
+  $between: ([from, to]) => (0, import_typeorm.Between)(from, to),
+  $not: (value) => (0, import_typeorm.Not)(value),
+  $ne: (value) => (0, import_typeorm.Not)(value),
+  $raw: (value) => (0, import_typeorm.Raw)((alias) => import_lodash.default.replace(value, "ALIAS", alias))
+};
+var existsOperator = (value) => {
+  let includeOp = false;
+  for (const op in OPERATORS) {
+    if (includeOp) continue;
+    includeOp = import_lodash.default.includes(JSON.stringify(value), op);
+  }
+  return includeOp;
+};
+var converter = (operator) => {
+  operator = import_lodash.default.isObject(operator) ? operator : JSON.parse(operator || "{}");
+  let convertion = operator;
+  for (const op in OPERATORS) {
+    if (!operator[op] && operator[op] !== 0) continue;
+    if (import_lodash.default.isObject(operator[op]) && import_lodash.default.isArray(operator[op])) {
+      import_lodash.default.forEach(operator[op], (condition, index) => {
+        if (!existsOperator(condition)) return;
+        for (const opSecondary in OPERATORS) {
+          if (!condition[opSecondary] && condition[opSecondary] !== 0) continue;
+          operator[op][index] = OPERATORS[opSecondary](condition[opSecondary]);
+        }
+      });
+    }
+    convertion = OPERATORS[op](operator[op]);
+  }
+  return convertion;
+};
+var refactorWhere = (where) => {
+  for (const key in where) {
+    let includeOp = existsOperator(where[key]);
+    if (includeOp) {
+      where[key] = converter(where[key]);
+      if (import_lodash.default.isObject(where[key]) && !import_lodash.default.isArray(where[key])) {
+        for (const keyObject in where[key]) {
+          includeOp = existsOperator(where[key][keyObject]);
+          if (!includeOp) continue;
+          where[key][keyObject] = converter(where[key][keyObject]);
+        }
+      }
+      if (import_lodash.default.isObject(where[key]) && import_lodash.default.isArray(where[key])) {
+        import_lodash.default.forEach(where[key], (condition, index) => {
+          includeOp = existsOperator(condition);
+          if (includeOp) {
+            condition = converter(condition);
+            if (import_lodash.default.isObject(condition) && !import_lodash.default.isArray(condition)) {
+              for (const keyObject in condition) {
+                includeOp = existsOperator(condition[keyObject]);
+                if (!includeOp) continue;
+                condition[keyObject] = converter(condition[keyObject]);
+              }
+            }
+          }
+          where[key][index] = condition;
+        });
+      }
+    }
+  }
+  return where;
+};
+
+// src/tools/paginate.ts
+var import_lodash2 = __toESM(require("lodash"));
+var parse = (json) => {
+  if (!json) return;
+  if (import_lodash2.default.isString(json)) return JSON.parse(json);
+  return json;
+};
+var paginate = async (repository, options) => {
+  let where = parse(options.filters);
+  if (where) where = refactorWhere(where);
+  const [data, count] = await repository.findAndCount({
+    select: options.fields,
+    relations: options.relations,
+    where,
+    order: parse(options.order),
+    take: options.limit,
+    skip: Number(options.page) * (Number(options.limit) || 0) || 0
+  });
+  return {
+    totalPage: Math.ceil(count / options.limit),
+    total: count,
+    content: data
+  };
+};
+
+// src/tools/moduler.ts
+var import_path = __toESM(require("path"));
+var import_fs = __toESM(require("fs"));
+var moduler = () => {
+  let content = {};
+  import_fs.default.readdirSync(__dirname).forEach((file) => {
+    if (file === "index.ts" || !file.endsWith(".ts")) return;
+    const filePath = import_path.default.join(__dirname, file);
+    const module2 = require(filePath);
+    content = { ...content, ...module2 };
+  });
+  return content;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  OPERATORS,
+  converter,
+  existsOperator,
+  moduler,
+  paginate,
+  refactorWhere,
   responseWrapper
 });

package/dist/src/tools/index.mjs

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/tools/response.ts
 var responseWrapper = async (res, promise) => {
   return promise.then((data) => {
@@ -12,6 +19,139 @@ var responseWrapper = async (res, promise) => {
     return res.status(status).send({ message: err.message, type: err.type, code: err.code });
   });
 };
+
+// src/tools/operators.ts
+import {
+  Like,
+  MoreThan,
+  MoreThanOrEqual,
+  In,
+  Not,
+  LessThan,
+  Between,
+  Raw,
+  And,
+  LessThanOrEqual
+} from "typeorm";
+import _ from "lodash";
+var OPERATORS = {
+  $in: (value) => In(value),
+  $and: (value) => And(value),
+  $notIn: (value) => Not(In(value)),
+  $like: (value) => Like(value),
+  $notLike: (value) => Not(Like(value)),
+  $gt: (value) => MoreThan(value),
+  $gte: (value) => MoreThanOrEqual(value),
+  $lt: (value) => LessThan(value),
+  $lte: (value) => LessThanOrEqual(value),
+  $between: ([from, to]) => Between(from, to),
+  $not: (value) => Not(value),
+  $ne: (value) => Not(value),
+  $raw: (value) => Raw((alias) => _.replace(value, "ALIAS", alias))
+};
+var existsOperator = (value) => {
+  let includeOp = false;
+  for (const op in OPERATORS) {
+    if (includeOp) continue;
+    includeOp = _.includes(JSON.stringify(value), op);
+  }
+  return includeOp;
+};
+var converter = (operator) => {
+  operator = _.isObject(operator) ? operator : JSON.parse(operator || "{}");
+  let convertion = operator;
+  for (const op in OPERATORS) {
+    if (!operator[op] && operator[op] !== 0) continue;
+    if (_.isObject(operator[op]) && _.isArray(operator[op])) {
+      _.forEach(operator[op], (condition, index) => {
+        if (!existsOperator(condition)) return;
+        for (const opSecondary in OPERATORS) {
+          if (!condition[opSecondary] && condition[opSecondary] !== 0) continue;
+          operator[op][index] = OPERATORS[opSecondary](condition[opSecondary]);
+        }
+      });
+    }
+    convertion = OPERATORS[op](operator[op]);
+  }
+  return convertion;
+};
+var refactorWhere = (where) => {
+  for (const key in where) {
+    let includeOp = existsOperator(where[key]);
+    if (includeOp) {
+      where[key] = converter(where[key]);
+      if (_.isObject(where[key]) && !_.isArray(where[key])) {
+        for (const keyObject in where[key]) {
+          includeOp = existsOperator(where[key][keyObject]);
+          if (!includeOp) continue;
+          where[key][keyObject] = converter(where[key][keyObject]);
+        }
+      }
+      if (_.isObject(where[key]) && _.isArray(where[key])) {
+        _.forEach(where[key], (condition, index) => {
+          includeOp = existsOperator(condition);
+          if (includeOp) {
+            condition = converter(condition);
+            if (_.isObject(condition) && !_.isArray(condition)) {
+              for (const keyObject in condition) {
+                includeOp = existsOperator(condition[keyObject]);
+                if (!includeOp) continue;
+                condition[keyObject] = converter(condition[keyObject]);
+              }
+            }
+          }
+          where[key][index] = condition;
+        });
+      }
+    }
+  }
+  return where;
+};
+
+// src/tools/paginate.ts
+import _2 from "lodash";
+var parse = (json) => {
+  if (!json) return;
+  if (_2.isString(json)) return JSON.parse(json);
+  return json;
+};
+var paginate = async (repository, options) => {
+  let where = parse(options.filters);
+  if (where) where = refactorWhere(where);
+  const [data, count] = await repository.findAndCount({
+    select: options.fields,
+    relations: options.relations,
+    where,
+    order: parse(options.order),
+    take: options.limit,
+    skip: Number(options.page) * (Number(options.limit) || 0) || 0
+  });
+  return {
+    totalPage: Math.ceil(count / options.limit),
+    total: count,
+    content: data
+  };
+};
+
+// src/tools/moduler.ts
+import path from "path";
+import fs from "fs";
+var moduler = () => {
+  let content = {};
+  fs.readdirSync(__dirname).forEach((file) => {
+    if (file === "index.ts" || !file.endsWith(".ts")) return;
+    const filePath = path.join(__dirname, file);
+    const module = __require(filePath);
+    content = { ...content, ...module };
+  });
+  return content;
+};
 export {
+  OPERATORS,
+  converter,
+  existsOperator,
+  moduler,
+  paginate,
+  refactorWhere,
   responseWrapper
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gustavo-valsechi/node",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",