@gustavo-valsechi/node 1.0.32 → 1.0.34

package/dist/index.d.mts

@@ -3,6 +3,8 @@ export { apiRouter, mainRouter } from './src/router/index.mjs';
 export { app, serverInit } from './src/server/index.mjs';
 export { OPERATORS, converter, existsOperator, moduler, paginate, refactorWhere, responseWrapper } from './src/tools/index.mjs';
 export { IMiddlewareContract, TenantService } from './src/services/index.mjs';
+export { OptionsSchema } from './src/schemas/index.mjs';
 import 'typeorm';
 import 'fastify';
 import 'http';
+import 'zod';

package/dist/index.d.ts

@@ -3,6 +3,8 @@ export { apiRouter, mainRouter } from './src/router/index.js';
 export { app, serverInit } from './src/server/index.js';
 export { OPERATORS, converter, existsOperator, moduler, paginate, refactorWhere, responseWrapper } from './src/tools/index.js';
 export { IMiddlewareContract, TenantService } from './src/services/index.js';
+export { OptionsSchema } from './src/schemas/index.js';
 import 'typeorm';
 import 'fastify';
 import 'http';
+import 'zod';

package/dist/index.js

@@ -31,6 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   OPERATORS: () => OPERATORS,
+  OptionsSchema: () => OptionsSchema,
   TenantService: () => TenantService,
   apiRouter: () => apiRouter,
   app: () => app,
@@ -148,6 +149,7 @@ var converter = (operator) => {
   return convertion;
 };
 var refactorWhere = (where) => {
+  if (!where) return where;
   for (const key in where) {
     let includeOp = existsOperator(where[key]);
     if (includeOp) {
@@ -180,26 +182,33 @@ var refactorWhere = (where) => {
   return where;
 };
 
-// src/tools/paginate.ts
+// src/schemas/options.ts
+var import_zod2 = require("zod");
 var import_lodash3 = __toESM(require("lodash"));
 var parse = (json) => {
   if (!json) return;
   if (import_lodash3.default.isString(json)) return JSON.parse(json);
   return json;
 };
+var OptionsSchema = import_zod2.z.object({
+  take: import_zod2.z.string().default("20").transform((value) => Number(value) ? Number(value) : value === "infinity" ? void 0 : 20),
+  page: import_zod2.z.string().default("0").transform((value) => Number(value) ? Number(value) : 0),
+  select: import_zod2.z.array(import_zod2.z.string()).optional(),
+  relations: import_zod2.z.array(import_zod2.z.string()).optional(),
+  where: import_zod2.z.any().transform((value) => refactorWhere(parse(value))).optional(),
+  order: import_zod2.z.any().default({ createdAt: "desc" }).transform((value) => parse(value))
+});
+
+// src/tools/paginate.ts
 var paginate = async (repository, options) => {
-  let where = parse(options.filters);
-  if (where) where = refactorWhere(where);
+  var _a;
+  const params = await OptionsSchema.parseAsync(options);
   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
+    skip: Number(params.page) * (Number(params.take) || 0) || 0,
+    ...params
   });
   return {
-    totalPage: Math.ceil(count / options.limit),
+    totalPage: options.take ? Math.ceil(count / options.take) : (_a = options.take) != null ? _a : 1,
     total: count,
     content: data
   };
@@ -345,6 +354,7 @@ var TenantService = class {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   OPERATORS,
+  OptionsSchema,
   TenantService,
   apiRouter,
   app,

package/dist/index.mjs

@@ -118,6 +118,7 @@ var converter = (operator) => {
   return convertion;
 };
 var refactorWhere = (where) => {
+  if (!where) return where;
   for (const key in where) {
     let includeOp = existsOperator(where[key]);
     if (includeOp) {
@@ -150,26 +151,33 @@ var refactorWhere = (where) => {
   return where;
 };
 
-// src/tools/paginate.ts
+// src/schemas/options.ts
+import { z } from "zod";
 import _3 from "lodash";
 var parse = (json) => {
   if (!json) return;
   if (_3.isString(json)) return JSON.parse(json);
   return json;
 };
+var OptionsSchema = z.object({
+  take: z.string().default("20").transform((value) => Number(value) ? Number(value) : value === "infinity" ? void 0 : 20),
+  page: z.string().default("0").transform((value) => Number(value) ? Number(value) : 0),
+  select: z.array(z.string()).optional(),
+  relations: z.array(z.string()).optional(),
+  where: z.any().transform((value) => refactorWhere(parse(value))).optional(),
+  order: z.any().default({ createdAt: "desc" }).transform((value) => parse(value))
+});
+
+// src/tools/paginate.ts
 var paginate = async (repository, options) => {
-  let where = parse(options.filters);
-  if (where) where = refactorWhere(where);
+  var _a;
+  const params = await OptionsSchema.parseAsync(options);
   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
+    skip: Number(params.page) * (Number(params.take) || 0) || 0,
+    ...params
   });
   return {
-    totalPage: Math.ceil(count / options.limit),
+    totalPage: options.take ? Math.ceil(count / options.take) : (_a = options.take) != null ? _a : 1,
     total: count,
     content: data
   };
@@ -314,6 +322,7 @@ var TenantService = class {
 };
 export {
   OPERATORS,
+  OptionsSchema,
   TenantService,
   apiRouter,
   app,

package/dist/src/router/index.js

@@ -60,9 +60,97 @@ var responseWrapper = async (res, promise) => {
 // src/tools/operators.ts
 var import_typeorm = require("typeorm");
 var import_lodash2 = __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_lodash2.default.replace(value, "ALIAS", alias))
+};
+var existsOperator = (value) => {
+  let includeOp = false;
+  for (const op in OPERATORS) {
+    if (includeOp) continue;
+    includeOp = import_lodash2.default.includes(JSON.stringify(value), op);
+  }
+  return includeOp;
+};
+var converter = (operator) => {
+  operator = import_lodash2.default.isObject(operator) ? operator : JSON.parse(operator || "{}");
+  let convertion = operator;
+  for (const op in OPERATORS) {
+    if (!operator[op] && operator[op] !== 0) continue;
+    if (import_lodash2.default.isObject(operator[op]) && import_lodash2.default.isArray(operator[op])) {
+      import_lodash2.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) => {
+  if (!where) return where;
+  for (const key in where) {
+    let includeOp = existsOperator(where[key]);
+    if (includeOp) {
+      where[key] = converter(where[key]);
+      if (import_lodash2.default.isObject(where[key]) && !import_lodash2.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_lodash2.default.isObject(where[key]) && import_lodash2.default.isArray(where[key])) {
+        import_lodash2.default.forEach(where[key], (condition, index) => {
+          includeOp = existsOperator(condition);
+          if (includeOp) {
+            condition = converter(condition);
+            if (import_lodash2.default.isObject(condition) && !import_lodash2.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
+// src/schemas/options.ts
+var import_zod2 = require("zod");
 var import_lodash3 = __toESM(require("lodash"));
+var parse = (json) => {
+  if (!json) return;
+  if (import_lodash3.default.isString(json)) return JSON.parse(json);
+  return json;
+};
+var OptionsSchema = import_zod2.z.object({
+  take: import_zod2.z.string().default("20").transform((value) => Number(value) ? Number(value) : value === "infinity" ? void 0 : 20),
+  page: import_zod2.z.string().default("0").transform((value) => Number(value) ? Number(value) : 0),
+  select: import_zod2.z.array(import_zod2.z.string()).optional(),
+  relations: import_zod2.z.array(import_zod2.z.string()).optional(),
+  where: import_zod2.z.any().transform((value) => refactorWhere(parse(value))).optional(),
+  order: import_zod2.z.any().default({ createdAt: "desc" }).transform((value) => parse(value))
+});
 
 // src/router/health.ts
 var healthRouter = (router, options, done) => {

package/dist/src/router/index.mjs

@@ -34,9 +34,97 @@ import {
   LessThanOrEqual
 } from "typeorm";
 import _2 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) => _2.replace(value, "ALIAS", alias))
+};
+var existsOperator = (value) => {
+  let includeOp = false;
+  for (const op in OPERATORS) {
+    if (includeOp) continue;
+    includeOp = _2.includes(JSON.stringify(value), op);
+  }
+  return includeOp;
+};
+var converter = (operator) => {
+  operator = _2.isObject(operator) ? operator : JSON.parse(operator || "{}");
+  let convertion = operator;
+  for (const op in OPERATORS) {
+    if (!operator[op] && operator[op] !== 0) continue;
+    if (_2.isObject(operator[op]) && _2.isArray(operator[op])) {
+      _2.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) => {
+  if (!where) return where;
+  for (const key in where) {
+    let includeOp = existsOperator(where[key]);
+    if (includeOp) {
+      where[key] = converter(where[key]);
+      if (_2.isObject(where[key]) && !_2.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 (_2.isObject(where[key]) && _2.isArray(where[key])) {
+        _2.forEach(where[key], (condition, index) => {
+          includeOp = existsOperator(condition);
+          if (includeOp) {
+            condition = converter(condition);
+            if (_2.isObject(condition) && !_2.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
+// src/schemas/options.ts
+import { z } from "zod";
 import _3 from "lodash";
+var parse = (json) => {
+  if (!json) return;
+  if (_3.isString(json)) return JSON.parse(json);
+  return json;
+};
+var OptionsSchema = z.object({
+  take: z.string().default("20").transform((value) => Number(value) ? Number(value) : value === "infinity" ? void 0 : 20),
+  page: z.string().default("0").transform((value) => Number(value) ? Number(value) : 0),
+  select: z.array(z.string()).optional(),
+  relations: z.array(z.string()).optional(),
+  where: z.any().transform((value) => refactorWhere(parse(value))).optional(),
+  order: z.any().default({ createdAt: "desc" }).transform((value) => parse(value))
+});
 
 // src/router/health.ts
 var healthRouter = (router, options, done) => {

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

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+declare const OptionsSchema: z.ZodObject<{
+    take: z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<number | undefined, string>>;
+    page: z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<number, string>>;
+    select: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    relations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    where: z.ZodOptional<z.ZodPipe<z.ZodAny, z.ZodTransform<any, any>>>;
+    order: z.ZodPipe<z.ZodDefault<z.ZodAny>, z.ZodTransform<any, any>>;
+}, z.core.$strip>;
+
+export { OptionsSchema };

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

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+declare const OptionsSchema: z.ZodObject<{
+    take: z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<number | undefined, string>>;
+    page: z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<number, string>>;
+    select: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    relations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    where: z.ZodOptional<z.ZodPipe<z.ZodAny, z.ZodTransform<any, any>>>;
+    order: z.ZodPipe<z.ZodDefault<z.ZodAny>, z.ZodTransform<any, any>>;
+}, z.core.$strip>;
+
+export { OptionsSchema };

package/dist/src/schemas/index.js

@@ -0,0 +1,134 @@
+"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);
+
+// src/schemas/index.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  OptionsSchema: () => OptionsSchema
+});
+module.exports = __toCommonJS(schemas_exports);
+
+// 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) => {
+  if (!where) return 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/schemas/options.ts
+var import_zod = require("zod");
+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 OptionsSchema = import_zod.z.object({
+  take: import_zod.z.string().default("20").transform((value) => Number(value) ? Number(value) : value === "infinity" ? void 0 : 20),
+  page: import_zod.z.string().default("0").transform((value) => Number(value) ? Number(value) : 0),
+  select: import_zod.z.array(import_zod.z.string()).optional(),
+  relations: import_zod.z.array(import_zod.z.string()).optional(),
+  where: import_zod.z.any().transform((value) => refactorWhere(parse(value))).optional(),
+  order: import_zod.z.any().default({ createdAt: "desc" }).transform((value) => parse(value))
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OptionsSchema
+});

package/dist/src/schemas/index.mjs

@@ -0,0 +1,108 @@
+// 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) => {
+  if (!where) return 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/schemas/options.ts
+import { z } from "zod";
+import _2 from "lodash";
+var parse = (json) => {
+  if (!json) return;
+  if (_2.isString(json)) return JSON.parse(json);
+  return json;
+};
+var OptionsSchema = z.object({
+  take: z.string().default("20").transform((value) => Number(value) ? Number(value) : value === "infinity" ? void 0 : 20),
+  page: z.string().default("0").transform((value) => Number(value) ? Number(value) : 0),
+  select: z.array(z.string()).optional(),
+  relations: z.array(z.string()).optional(),
+  where: z.any().transform((value) => refactorWhere(parse(value))).optional(),
+  order: z.any().default({ createdAt: "desc" }).transform((value) => parse(value))
+});
+export {
+  OptionsSchema
+};

package/dist/src/server/index.js

@@ -61,9 +61,97 @@ var responseWrapper = async (res, promise) => {
 // src/tools/operators.ts
 var import_typeorm = require("typeorm");
 var import_lodash2 = __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_lodash2.default.replace(value, "ALIAS", alias))
+};
+var existsOperator = (value) => {
+  let includeOp = false;
+  for (const op in OPERATORS) {
+    if (includeOp) continue;
+    includeOp = import_lodash2.default.includes(JSON.stringify(value), op);
+  }
+  return includeOp;
+};
+var converter = (operator) => {
+  operator = import_lodash2.default.isObject(operator) ? operator : JSON.parse(operator || "{}");
+  let convertion = operator;
+  for (const op in OPERATORS) {
+    if (!operator[op] && operator[op] !== 0) continue;
+    if (import_lodash2.default.isObject(operator[op]) && import_lodash2.default.isArray(operator[op])) {
+      import_lodash2.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) => {
+  if (!where) return where;
+  for (const key in where) {
+    let includeOp = existsOperator(where[key]);
+    if (includeOp) {
+      where[key] = converter(where[key]);
+      if (import_lodash2.default.isObject(where[key]) && !import_lodash2.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_lodash2.default.isObject(where[key]) && import_lodash2.default.isArray(where[key])) {
+        import_lodash2.default.forEach(where[key], (condition, index) => {
+          includeOp = existsOperator(condition);
+          if (includeOp) {
+            condition = converter(condition);
+            if (import_lodash2.default.isObject(condition) && !import_lodash2.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
+// src/schemas/options.ts
+var import_zod2 = require("zod");
 var import_lodash3 = __toESM(require("lodash"));
+var parse = (json) => {
+  if (!json) return;
+  if (import_lodash3.default.isString(json)) return JSON.parse(json);
+  return json;
+};
+var OptionsSchema = import_zod2.z.object({
+  take: import_zod2.z.string().default("20").transform((value) => Number(value) ? Number(value) : value === "infinity" ? void 0 : 20),
+  page: import_zod2.z.string().default("0").transform((value) => Number(value) ? Number(value) : 0),
+  select: import_zod2.z.array(import_zod2.z.string()).optional(),
+  relations: import_zod2.z.array(import_zod2.z.string()).optional(),
+  where: import_zod2.z.any().transform((value) => refactorWhere(parse(value))).optional(),
+  order: import_zod2.z.any().default({ createdAt: "desc" }).transform((value) => parse(value))
+});
 
 // src/router/health.ts
 var healthRouter = (router, options, done) => {

package/dist/src/server/index.mjs

@@ -37,9 +37,97 @@ import {
   LessThanOrEqual
 } from "typeorm";
 import _2 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) => _2.replace(value, "ALIAS", alias))
+};
+var existsOperator = (value) => {
+  let includeOp = false;
+  for (const op in OPERATORS) {
+    if (includeOp) continue;
+    includeOp = _2.includes(JSON.stringify(value), op);
+  }
+  return includeOp;
+};
+var converter = (operator) => {
+  operator = _2.isObject(operator) ? operator : JSON.parse(operator || "{}");
+  let convertion = operator;
+  for (const op in OPERATORS) {
+    if (!operator[op] && operator[op] !== 0) continue;
+    if (_2.isObject(operator[op]) && _2.isArray(operator[op])) {
+      _2.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) => {
+  if (!where) return where;
+  for (const key in where) {
+    let includeOp = existsOperator(where[key]);
+    if (includeOp) {
+      where[key] = converter(where[key]);
+      if (_2.isObject(where[key]) && !_2.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 (_2.isObject(where[key]) && _2.isArray(where[key])) {
+        _2.forEach(where[key], (condition, index) => {
+          includeOp = existsOperator(condition);
+          if (includeOp) {
+            condition = converter(condition);
+            if (_2.isObject(condition) && !_2.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
+// src/schemas/options.ts
+import { z } from "zod";
 import _3 from "lodash";
+var parse = (json) => {
+  if (!json) return;
+  if (_3.isString(json)) return JSON.parse(json);
+  return json;
+};
+var OptionsSchema = z.object({
+  take: z.string().default("20").transform((value) => Number(value) ? Number(value) : value === "infinity" ? void 0 : 20),
+  page: z.string().default("0").transform((value) => Number(value) ? Number(value) : 0),
+  select: z.array(z.string()).optional(),
+  relations: z.array(z.string()).optional(),
+  where: z.any().transform((value) => refactorWhere(parse(value))).optional(),
+  order: z.any().default({ createdAt: "desc" }).transform((value) => parse(value))
+});
 
 // src/router/health.ts
 var healthRouter = (router, options, done) => {

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

@@ -1,4 +1,6 @@
 import { FastifyReply } from 'fastify';
+import { OptionsSchema } from '../schemas/index.mjs';
+import { z } from 'zod';
 
 declare const responseWrapper: (res: FastifyReply, promise: Promise<any>) => Promise<void>;
 
@@ -7,18 +9,7 @@ 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<{
+declare const paginate: (repository: any, options: z.infer<typeof OptionsSchema>) => Promise<{
     totalPage: number;
     total: any;
     content: any;

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

@@ -1,4 +1,6 @@
 import { FastifyReply } from 'fastify';
+import { OptionsSchema } from '../schemas/index.js';
+import { z } from 'zod';
 
 declare const responseWrapper: (res: FastifyReply, promise: Promise<any>) => Promise<void>;
 
@@ -7,18 +9,7 @@ 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<{
+declare const paginate: (repository: any, options: z.infer<typeof OptionsSchema>) => Promise<{
     totalPage: number;
     total: any;
     content: any;

package/dist/src/tools/index.js

@@ -107,6 +107,7 @@ var converter = (operator) => {
   return convertion;
 };
 var refactorWhere = (where) => {
+  if (!where) return where;
   for (const key in where) {
     let includeOp = existsOperator(where[key]);
     if (includeOp) {
@@ -139,26 +140,33 @@ var refactorWhere = (where) => {
   return where;
 };
 
-// src/tools/paginate.ts
+// src/schemas/options.ts
+var import_zod2 = require("zod");
 var import_lodash3 = __toESM(require("lodash"));
 var parse = (json) => {
   if (!json) return;
   if (import_lodash3.default.isString(json)) return JSON.parse(json);
   return json;
 };
+var OptionsSchema = import_zod2.z.object({
+  take: import_zod2.z.string().default("20").transform((value) => Number(value) ? Number(value) : value === "infinity" ? void 0 : 20),
+  page: import_zod2.z.string().default("0").transform((value) => Number(value) ? Number(value) : 0),
+  select: import_zod2.z.array(import_zod2.z.string()).optional(),
+  relations: import_zod2.z.array(import_zod2.z.string()).optional(),
+  where: import_zod2.z.any().transform((value) => refactorWhere(parse(value))).optional(),
+  order: import_zod2.z.any().default({ createdAt: "desc" }).transform((value) => parse(value))
+});
+
+// src/tools/paginate.ts
 var paginate = async (repository, options) => {
-  let where = parse(options.filters);
-  if (where) where = refactorWhere(where);
+  var _a;
+  const params = await OptionsSchema.parseAsync(options);
   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
+    skip: Number(params.page) * (Number(params.take) || 0) || 0,
+    ...params
   });
   return {
-    totalPage: Math.ceil(count / options.limit),
+    totalPage: options.take ? Math.ceil(count / options.take) : (_a = options.take) != null ? _a : 1,
     total: count,
     content: data
   };

package/dist/src/tools/index.mjs

@@ -83,6 +83,7 @@ var converter = (operator) => {
   return convertion;
 };
 var refactorWhere = (where) => {
+  if (!where) return where;
   for (const key in where) {
     let includeOp = existsOperator(where[key]);
     if (includeOp) {
@@ -115,26 +116,33 @@ var refactorWhere = (where) => {
   return where;
 };
 
-// src/tools/paginate.ts
+// src/schemas/options.ts
+import { z } from "zod";
 import _3 from "lodash";
 var parse = (json) => {
   if (!json) return;
   if (_3.isString(json)) return JSON.parse(json);
   return json;
 };
+var OptionsSchema = z.object({
+  take: z.string().default("20").transform((value) => Number(value) ? Number(value) : value === "infinity" ? void 0 : 20),
+  page: z.string().default("0").transform((value) => Number(value) ? Number(value) : 0),
+  select: z.array(z.string()).optional(),
+  relations: z.array(z.string()).optional(),
+  where: z.any().transform((value) => refactorWhere(parse(value))).optional(),
+  order: z.any().default({ createdAt: "desc" }).transform((value) => parse(value))
+});
+
+// src/tools/paginate.ts
 var paginate = async (repository, options) => {
-  let where = parse(options.filters);
-  if (where) where = refactorWhere(where);
+  var _a;
+  const params = await OptionsSchema.parseAsync(options);
   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
+    skip: Number(params.page) * (Number(params.take) || 0) || 0,
+    ...params
   });
   return {
-    totalPage: Math.ceil(count / options.limit),
+    totalPage: options.take ? Math.ceil(count / options.take) : (_a = options.take) != null ? _a : 1,
     total: count,
     content: data
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gustavo-valsechi/node",
-  "version": "1.0.32",
+  "version": "1.0.34",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -67,6 +67,11 @@
       "require": "./dist/src/router/index.js",
       "import": "./dist/src/router/index.js"
     },
+    "./schemas": {
+      "types": "./dist/src/schemas/index.d.ts",
+      "require": "./dist/src/schemas/index.js",
+      "import": "./dist/src/schemas/index.js"
+    },
     "./server": {
       "types": "./dist/src/server/index.d.ts",
       "require": "./dist/src/server/index.js",