@navservice/core 1.116.0 → 1.120.0

package/build/lib/helpers.cjs

@@ -112,7 +112,7 @@ const _logger = new RequestLoggerClass();
 
 const set_response = new class set_response {
     c = new class c {
-        SUCCESS({ message, results, c }) {
+        SUCCESS({ message, results, c, fn }) {
             const payload = {
                 status: 200,
                 code: "SUCCESS",
@@ -121,7 +121,7 @@ const set_response = new class set_response {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "SUCCESS",
+                fn: `${fn}_SUCCESS`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
@@ -130,7 +130,7 @@ const set_response = new class set_response {
                 status: 200
             });
         }
-        ACTION_REQUIRED({ message, results, c }) {
+        ACTION_REQUIRED({ message, results, c, fn }) {
             const payload = {
                 status: 428,
                 code: "ACTION_REQUIRED",
@@ -139,7 +139,7 @@ const set_response = new class set_response {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "ACTION_REQUIRED",
+                fn: `${fn}_ACTION_REQUIRED`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
@@ -148,7 +148,7 @@ const set_response = new class set_response {
                 status: 428
             });
         }
-        CREATED({ message, results, c }) {
+        CREATED({ message, results, c, fn }) {
             const payload = {
                 status: 201,
                 code: "CREATED",
@@ -157,7 +157,7 @@ const set_response = new class set_response {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "CREATED",
+                fn: `${fn}_CREATED`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
@@ -166,7 +166,7 @@ const set_response = new class set_response {
                 status: 201
             });
         }
-        WARNING({ message, results, c }) {
+        WARNING({ message, results, c, fn }) {
             const payload = {
                 status: 400,
                 code: "WARNING",
@@ -175,7 +175,7 @@ const set_response = new class set_response {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "WARNING",
+                fn: `${fn}_WARNING`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
@@ -184,7 +184,7 @@ const set_response = new class set_response {
                 status: 400
             });
         }
-        AUTHORIZATION_ERROR({ message, results, c }) {
+        AUTHORIZATION_ERROR({ message, results, c, fn }) {
             const payload = {
                 status: 405,
                 code: "WARNING",
@@ -193,7 +193,7 @@ const set_response = new class set_response {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "AUTHORIZATION_ERROR",
+                fn: `${fn}_AUTHORIZATION_ERROR`,
                 level: "error",
                 message: payload?.message,
                 results: payload?.results
@@ -202,7 +202,7 @@ const set_response = new class set_response {
                 status: 405
             });
         }
-        SERVER_ERROR({ error, c }) {
+        SERVER_ERROR({ error, c, fn }) {
             if (error instanceof (v4_default()).ZodError) {
                 const payload = {
                     status: 500,
@@ -212,7 +212,7 @@ const set_response = new class set_response {
                     results: v4_default().treeifyError(error)
                 };
                 helpers_logger.add({
-                    fn: "SCHEMA_VALIDATION",
+                    fn: `${fn}_SCHEMA_VALIDATION`,
                     level: "error",
                     message: payload?.message,
                     results: payload?.results
@@ -230,7 +230,7 @@ const set_response = new class set_response {
             };
             if (payload?.type === "error") {
                 helpers_logger.add({
-                    fn: "SERVER_ERROR",
+                    fn: `${fn}_SERVER_ERROR`,
                     level: payload?.type,
                     message: payload?.message,
                     results: payload?.results
@@ -240,7 +240,7 @@ const set_response = new class set_response {
                 status: error?.status || error?.status || 500
             });
         }
-        UNAUTHORIZED({ message, c }) {
+        UNAUTHORIZED({ message, c, fn }) {
             const payload = {
                 status: 401,
                 code: "UNAUTHORIZED",
@@ -249,7 +249,7 @@ const set_response = new class set_response {
                 results: []
             };
             helpers_logger.add({
-                fn: "UNAUTHORIZED",
+                fn: `${fn}_UNAUTHORIZED`,
                 level: "error",
                 message: payload?.message,
                 results: payload?.results
@@ -258,7 +258,7 @@ const set_response = new class set_response {
                 status: 401
             });
         }
-        INVALID_TOKEN({ message, c }) {
+        INVALID_TOKEN({ message, c, fn }) {
             const payload = {
                 status: 409,
                 code: "INVALID_TOKEN",
@@ -267,7 +267,7 @@ const set_response = new class set_response {
                 results: []
             };
             helpers_logger.add({
-                fn: "INVALID_TOKEN",
+                fn: `${fn}_INVALID_TOKEN`,
                 level: "error",
                 message: payload?.message,
                 results: payload?.results
@@ -276,7 +276,7 @@ const set_response = new class set_response {
                 status: 409
             });
         }
-        NOT_FOUND({ message, c }) {
+        NOT_FOUND({ message, c, fn }) {
             const payload = {
                 status: 404,
                 code: "NOT_FOUND",
@@ -285,7 +285,7 @@ const set_response = new class set_response {
                 results: []
             };
             helpers_logger.add({
-                fn: "NOT_FOUND",
+                fn: `${fn}_NOT_FOUND`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
@@ -294,14 +294,14 @@ const set_response = new class set_response {
                 status: 404
             });
         }
-        async SUCCESS_FILE({ message, file_buffer, content_type, filename, c }) {
+        async SUCCESS_FILE({ message, file_buffer, content_type, filename, c, fn }) {
             if (c && content_type) {
                 const headers = {
                     "Content-Type": content_type,
                     "Content-Disposition": filename ? `inline; filename="${filename}"` : "inline"
                 };
                 helpers_logger.add({
-                    fn: "SUCCESS_FILE",
+                    fn: `${fn}_SUCCESS_FILE`,
                     level: "info",
                     message: "",
                     results: headers
@@ -319,7 +319,7 @@ const set_response = new class set_response {
                 results: []
             };
             helpers_logger.add({
-                fn: "SUCCESS_FILE",
+                fn: `${fn}_SUCCESS_FILE`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
@@ -330,7 +330,7 @@ const set_response = new class set_response {
         }
     };
     error = new class error {
-        ACTION_REQUIRED({ message, results }) {
+        ACTION_REQUIRED({ message, results, fn }) {
             const payload = {
                 status: 428,
                 code: "ACTION_REQUIRED",
@@ -339,14 +339,14 @@ const set_response = new class set_response {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "ACTION_REQUIRED",
+                fn: `${fn}_ACTION_REQUIRED`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
             });
             throw payload;
         }
-        WARNING({ message, results }) {
+        WARNING({ message, results, fn }) {
             const payload = {
                 status: 400,
                 code: "WARNING",
@@ -355,14 +355,46 @@ const set_response = new class set_response {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "WARNING",
+                fn: `${fn}_WARNING`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
             });
             throw payload;
         }
-        AUTHORIZATION_ERROR({ message, results }) {
+        ERROR({ message, results, fn }) {
+            const payload = {
+                status: 400,
+                code: "ERROR",
+                type: "error",
+                message: message || "Aviso!",
+                results: results || []
+            };
+            helpers_logger.add({
+                fn: `${fn}_ERROR`,
+                level: "info",
+                message: payload?.message,
+                results: payload?.results
+            });
+            throw payload;
+        }
+        TOKEN_AUTH_USER({ message, results, fn }) {
+            const payload = {
+                status: 410,
+                code: "TOKEN_AUTH_USER",
+                type: "warning",
+                message: message || "Erro processo de auth token!",
+                results: results || []
+            };
+            helpers_logger.add({
+                fn: `${fn}_REFRESH_TOKEN_AUTH_USER`,
+                level: "error",
+                message: payload?.message,
+                results: payload?.results
+            });
+            throw payload;
+        }
+        AUTHORIZATION_ERROR({ message, results, fn }) {
             const payload = {
                 status: 400,
                 code: "WARNING",
@@ -371,7 +403,7 @@ const set_response = new class set_response {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "AUTHORIZATION_ERROR",
+                fn: `${fn}_AUTHORIZATION_ERROR`,
                 level: "error",
                 message: payload?.message,
                 results: payload?.results
@@ -379,7 +411,7 @@ const set_response = new class set_response {
             throw payload;
         }
         // CONTEM _LOGGER PARA FACILITAR OS LOGS DE TRACING DO SISTEMA
-        DATABASE_ERROR({ message, erro }) {
+        DATABASE_ERROR({ message, erro, fn }) {
             const errorCode = erro?.cause?.code || erro?.cause?.cause?.code || erro?.code || "";
             const map = {
                 "SQLITE_CONSTRAINT_UNIQUE": {
@@ -423,14 +455,14 @@ const set_response = new class set_response {
                 results: []
             };
             helpers_logger.add({
-                fn: "DATABASE_ERROR",
+                fn: `${fn}_DATABASE_ERROR`,
                 level: "error",
                 message: payload?.message,
                 results: erro
             });
             throw payload;
         }
-        SCHEMA_VALIDATION({ results }) {
+        SCHEMA_VALIDATION({ results, fn }) {
             const payload = {
                 status: 500,
                 code: "SCHEMA_VALIDATION",
@@ -439,14 +471,14 @@ const set_response = new class set_response {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "SCHEMA_VALIDATION",
+                fn: `${fn}_SCHEMA_VALIDATION`,
                 level: "error",
                 message: payload?.message,
                 results: payload?.results
             });
             throw payload;
         }
-        UNAUTHORIZED({ message }) {
+        UNAUTHORIZED({ message, fn }) {
             const payload = {
                 status: 401,
                 code: "UNAUTHORIZED",
@@ -454,60 +486,62 @@ const set_response = new class set_response {
                 message: message || "Não autorizado!"
             };
             helpers_logger.add({
-                fn: "UNAUTHORIZED",
+                fn: `${fn}_UNAUTHORIZED`,
                 level: "error",
                 message: payload?.message,
                 results: payload?.results
             });
             throw payload;
         }
-        INTEGRATION_ERROR({ message }) {
+        INTEGRATION_ERROR({ message, fn, erro }) {
             const payload = {
                 status: 401,
                 code: "INTEGRATION_ERROR",
                 type: "error",
-                message: message || "Erro na camada de integração!"
+                message: message || "Erro na camada de integração!",
+                results: erro
             };
             helpers_logger.add({
-                fn: "INTEGRATION_ERROR",
+                fn: `${fn}_INTEGRATION_ERROR`,
                 level: "error",
                 message: payload?.message,
-                results: payload?.results
+                results: erro
             });
             throw payload;
         }
-        INVALID_TOKEN({ message }) {
+        INVALID_TOKEN({ message, fn, results }) {
             const payload = {
                 status: 401,
                 code: "INVALID_TOKEN",
                 type: "warning",
                 message: message || "Token inválido!",
-                results: []
+                results: results || []
             };
             helpers_logger.add({
-                fn: "INVALID_TOKEN",
+                fn: `${fn}_INVALID_TOKEN`,
                 level: "error",
                 message: payload?.message,
                 results: payload?.results
             });
             throw payload;
         }
-        NOT_FOUND({ message }) {
+        NOT_FOUND({ message, fn, results }) {
             const payload = {
                 status: 404,
                 code: "NOT_FOUND",
                 type: "error",
-                message: message || "Recurso não encontrado!"
+                message: message || "Recurso não encontrado!",
+                results: results || []
             };
             helpers_logger.add({
-                fn: "NOT_FOUND",
+                fn: `${fn}_NOT_FOUND`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
             });
             throw payload;
         }
-        BUSINESS_RULE_VIOLATION({ message, results }) {
+        BUSINESS_RULE_VIOLATION({ message, results, fn }) {
             const payload = {
                 status: 422,
                 code: "BUSINESS_RULE_VIOLATION",
@@ -516,14 +550,14 @@ const set_response = new class set_response {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "BUSINESS_RULE_VIOLATION",
+                fn: `${fn}_BUSINESS_RULE_VIOLATION`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
             });
             throw payload;
         }
-        PLAN_FORBIDDEN({ message, results }) {
+        PLAN_FORBIDDEN({ message, results, fn }) {
             const payload = {
                 status: 403,
                 code: "PLAN_FORBIDDEN",
@@ -532,7 +566,7 @@ const set_response = new class set_response {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "PLAN_FORBIDDEN",
+                fn: `${fn}_PLAN_FORBIDDEN`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
@@ -549,6 +583,7 @@ const external_jose_namespaceObject = require("jose");
 
 // Tem que importar assim para evitar dependencia circular
 
+const _token_fn = 'token';
 const _token = new class _token {
     async verificar_token(c, next) {
         try {
@@ -556,13 +591,15 @@ const _token = new class _token {
             if (!authHeader) return _set_response.c.INVALID_TOKEN({
                 message: 'token não enviado!!!',
                 c: c,
-                results: []
+                results: [],
+                fn: _token_fn
             });
             const token = authHeader.split(" ")[1];
             if (!token) return _set_response.c.INVALID_TOKEN({
                 message: 'Acesso negado!!!',
                 c: c,
-                results: []
+                results: [],
+                fn: _token_fn
             });
             const secret = new TextEncoder().encode(c.env.JSON_WEB_TOKEN_AUTH_USER);
             const { payload } = await external_jose_namespaceObject.jwtVerify(token, secret);
@@ -570,7 +607,8 @@ const _token = new class _token {
                 return _set_response.c.INVALID_TOKEN({
                     message: 'Token inválido!!!!',
                     c: c,
-                    results: []
+                    results: [],
+                    fn: _token_fn
                 });
             }
             const setar_token = {
@@ -591,15 +629,17 @@ const _token = new class _token {
             return _set_response.c.INVALID_TOKEN({
                 message: 'Token inválido!!!',
                 c: c,
-                results: []
+                results: [],
+                fn: _token_fn
             });
         }
     }
     async criar_token_login_usuario(props) {
         if (!props?.c.env.JSON_WEB_TOKEN_AUTH_USER) {
             _set_response.error.WARNING({
-                message: "Erro ao gerar token!!",
-                results: []
+                message: "Erro ao gerar token auth!!",
+                results: [],
+                fn: _token_fn
             });
         }
         const token = await new external_jose_namespaceObject.SignJWT({
@@ -615,9 +655,10 @@ const _token = new class _token {
         }).setProtectedHeader({
             alg: "HS256"
         }).setIssuedAt().setExpirationTime("1h").sign(new TextEncoder().encode(props?.c.env.JSON_WEB_TOKEN_AUTH_USER)).catch((error)=>{
-            return _set_response.error.WARNING({
-                message: "Erro ao gerar token!",
-                results: error?.message
+            return _set_response.error.TOKEN_AUTH_USER({
+                message: "Erro ao gerar token auth user!",
+                results: error?.message,
+                fn: _token_fn
             });
         });
         return token;
@@ -628,13 +669,15 @@ const _token = new class _token {
             if (!authHeader) return _set_response.c.INVALID_TOKEN({
                 message: 'token service não enviado!',
                 c: c,
-                results: []
+                results: [],
+                fn: _token_fn
             });
             const token = authHeader.split(" ")[1];
             if (!token) return _set_response.c.INVALID_TOKEN({
                 message: 'Acesso negado ao serviço!',
                 c: c,
-                results: []
+                results: [],
+                fn: _token_fn
             });
             const secret = new TextEncoder().encode(c.env.JSON_WEB_TOKEN_AUTH_MICRO_SERVICO);
             const { payload } = await external_jose_namespaceObject.jwtVerify(token, secret);
@@ -642,7 +685,8 @@ const _token = new class _token {
                 return _set_response.c.INVALID_TOKEN({
                     message: 'Token inválido para o serviço!',
                     c: c,
-                    results: []
+                    results: [],
+                    fn: _token_fn
                 });
             }
             const setar_token = {
@@ -662,15 +706,17 @@ const _token = new class _token {
             return _set_response.c.INVALID_TOKEN({
                 message: 'Erro token inválido!',
                 c: c,
-                results: []
+                results: [],
+                fn: _token_fn
             });
         }
     }
     async criar_token_micro_servico({ c }) {
         if (!c.env.JSON_WEB_TOKEN_AUTH_MICRO_SERVICO) {
-            return _set_response.error.WARNING({
+            _set_response.error.WARNING({
                 message: "Erro ao gerar token!!",
-                results: []
+                results: [],
+                fn: _token_fn
             });
         }
         const usuario_auth = c.get("usuario_auth");
@@ -687,18 +733,20 @@ const _token = new class _token {
         }).setProtectedHeader({
             alg: "HS256"
         }).setIssuedAt().setExpirationTime("30s").sign(new TextEncoder().encode(c.env.JSON_WEB_TOKEN_AUTH_MICRO_SERVICO)).catch((error)=>{
-            return _set_response.error.WARNING({
-                message: "Erro ao gerar token!",
-                results: error?.message
+            return _set_response.error.TOKEN_AUTH_USER({
+                message: "Erro ao gerar token micro serviço!",
+                results: error?.message,
+                fn: _token_fn
             });
         });
         return token;
     }
     async criar_refresh_token({ env, usuario_id }) {
         if (!env.JSON_WEB_REFRESH_TOKEN_AUTH_USER) {
-            return _set_response.error.WARNING({
+            _set_response.error.TOKEN_AUTH_USER({
                 message: "Erro ao gerar refresh token!!",
-                results: []
+                results: [],
+                fn: _token_fn
             });
         }
         const token = await new external_jose_namespaceObject.SignJWT({
@@ -706,8 +754,9 @@ const _token = new class _token {
         }).setProtectedHeader({
             alg: "HS256"
         }).setIssuedAt().setExpirationTime("2h").sign(new TextEncoder().encode(env.JSON_WEB_REFRESH_TOKEN_AUTH_USER)).catch((error)=>{
-            return _set_response.error.WARNING({
-                message: "Erro ao gerar refresh token!"
+            return _set_response.error.TOKEN_AUTH_USER({
+                message: "Erro ao gerar refresh token!",
+                fn: _token_fn
             });
         });
         return token;

package/build/lib/index.cjs

@@ -144,6 +144,7 @@ var _usuario_TypeControllerUsuario;
         v4_default().literal("ACTION_REQUIRED"),
         v4_default().literal("CREATED"),
         v4_default().literal("WARNING"),
+        v4_default().literal("ERROR"),
         v4_default().literal("AUTHORIZATION_ERROR"),
         v4_default().literal("SCHEMA_VALIDATION"),
         v4_default().literal("SERVER_ERROR"),
@@ -154,7 +155,8 @@ var _usuario_TypeControllerUsuario;
         v4_default().literal("DATABASE_ERROR"),
         v4_default().literal("BUSINESS_RULE_VIOLATION"),
         v4_default().literal("PLAN_FORBIDDEN"),
-        v4_default().literal("INTEGRATION_ERROR")
+        v4_default().literal("INTEGRATION_ERROR"),
+        v4_default().literal("TOKEN_AUTH_USER")
     ]);
     const BaseResponseSchema = v4_default().object({
         status: StatusSchema,
@@ -176,6 +178,7 @@ var _usuario_TypeControllerUsuario;
         const FileResponseParamsSchema = v4_default().object({
             status: StatusSchema,
             message: v4_default().string().optional(),
+            fn: v4_default().string(),
             file_buffer: v4_default().union([
                 v4_default()["instanceof"](Blob),
                 v4_default()["instanceof"](ArrayBuffer),
@@ -195,8 +198,7 @@ var _usuario_TypeControllerUsuario;
             ]).optional(),
             type: TypeSchema.optional().default("success"),
             code: CodeSchema,
-            status: v4_default().number().optional().default(200),
-            fn: v4_default().string().optional()
+            status: v4_default().number().optional().default(200)
         });
     })(TypeControllerResponse.Error || (TypeControllerResponse.Error = {}));
 })(_type_response_TypeControllerResponse || (_type_response_TypeControllerResponse = {}));

package/build/lib/types/_type_response.d.ts

@@ -3,7 +3,7 @@ import z4 from "zod/v4";
 declare namespace TypeControllerResponse {
     const BaseResponseSchema: z4.ZodObject<{
         status: z4.ZodUnion<readonly [z4.ZodLiteral<200>, z4.ZodLiteral<201>, z4.ZodLiteral<202>, z4.ZodLiteral<204>, z4.ZodLiteral<400>, z4.ZodLiteral<401>, z4.ZodLiteral<403>, z4.ZodLiteral<404>, z4.ZodLiteral<409>, z4.ZodLiteral<422>, z4.ZodLiteral<500>, z4.ZodLiteral<428>, z4.ZodLiteral<405>]>;
-        code: z4.ZodUnion<readonly [z4.ZodLiteral<"SUCCESS">, z4.ZodLiteral<"ACTION_REQUIRED">, z4.ZodLiteral<"CREATED">, z4.ZodLiteral<"WARNING">, z4.ZodLiteral<"AUTHORIZATION_ERROR">, z4.ZodLiteral<"SCHEMA_VALIDATION">, z4.ZodLiteral<"SERVER_ERROR">, z4.ZodLiteral<"UNAUTHORIZED">, z4.ZodLiteral<"INVALID_TOKEN">, z4.ZodLiteral<"NOT_FOUND">, z4.ZodLiteral<"SUCCESS_FILE">, z4.ZodLiteral<"DATABASE_ERROR">, z4.ZodLiteral<"BUSINESS_RULE_VIOLATION">, z4.ZodLiteral<"PLAN_FORBIDDEN">, z4.ZodLiteral<"INTEGRATION_ERROR">]>;
+        code: z4.ZodUnion<readonly [z4.ZodLiteral<"SUCCESS">, z4.ZodLiteral<"ACTION_REQUIRED">, z4.ZodLiteral<"CREATED">, z4.ZodLiteral<"WARNING">, z4.ZodLiteral<"ERROR">, z4.ZodLiteral<"AUTHORIZATION_ERROR">, z4.ZodLiteral<"SCHEMA_VALIDATION">, z4.ZodLiteral<"SERVER_ERROR">, z4.ZodLiteral<"UNAUTHORIZED">, z4.ZodLiteral<"INVALID_TOKEN">, z4.ZodLiteral<"NOT_FOUND">, z4.ZodLiteral<"SUCCESS_FILE">, z4.ZodLiteral<"DATABASE_ERROR">, z4.ZodLiteral<"BUSINESS_RULE_VIOLATION">, z4.ZodLiteral<"PLAN_FORBIDDEN">, z4.ZodLiteral<"INTEGRATION_ERROR">, z4.ZodLiteral<"TOKEN_AUTH_USER">]>;
         type: z4.ZodDefault<z4.ZodUnion<readonly [z4.ZodLiteral<"success">, z4.ZodLiteral<"warning">, z4.ZodLiteral<"error">]>>;
         message: z4.ZodString;
         results: z4.ZodOptional<z4.ZodUnknown>;
@@ -15,7 +15,7 @@ declare namespace TypeControllerResponse {
     export namespace C {
         export const InputSchema: z4.ZodObject<{
             status: z4.ZodUnion<readonly [z4.ZodLiteral<200>, z4.ZodLiteral<201>, z4.ZodLiteral<202>, z4.ZodLiteral<204>, z4.ZodLiteral<400>, z4.ZodLiteral<401>, z4.ZodLiteral<403>, z4.ZodLiteral<404>, z4.ZodLiteral<409>, z4.ZodLiteral<422>, z4.ZodLiteral<500>, z4.ZodLiteral<428>, z4.ZodLiteral<405>]>;
-            code: z4.ZodUnion<readonly [z4.ZodLiteral<"SUCCESS">, z4.ZodLiteral<"ACTION_REQUIRED">, z4.ZodLiteral<"CREATED">, z4.ZodLiteral<"WARNING">, z4.ZodLiteral<"AUTHORIZATION_ERROR">, z4.ZodLiteral<"SCHEMA_VALIDATION">, z4.ZodLiteral<"SERVER_ERROR">, z4.ZodLiteral<"UNAUTHORIZED">, z4.ZodLiteral<"INVALID_TOKEN">, z4.ZodLiteral<"NOT_FOUND">, z4.ZodLiteral<"SUCCESS_FILE">, z4.ZodLiteral<"DATABASE_ERROR">, z4.ZodLiteral<"BUSINESS_RULE_VIOLATION">, z4.ZodLiteral<"PLAN_FORBIDDEN">, z4.ZodLiteral<"INTEGRATION_ERROR">]>;
+            code: z4.ZodUnion<readonly [z4.ZodLiteral<"SUCCESS">, z4.ZodLiteral<"ACTION_REQUIRED">, z4.ZodLiteral<"CREATED">, z4.ZodLiteral<"WARNING">, z4.ZodLiteral<"ERROR">, z4.ZodLiteral<"AUTHORIZATION_ERROR">, z4.ZodLiteral<"SCHEMA_VALIDATION">, z4.ZodLiteral<"SERVER_ERROR">, z4.ZodLiteral<"UNAUTHORIZED">, z4.ZodLiteral<"INVALID_TOKEN">, z4.ZodLiteral<"NOT_FOUND">, z4.ZodLiteral<"SUCCESS_FILE">, z4.ZodLiteral<"DATABASE_ERROR">, z4.ZodLiteral<"BUSINESS_RULE_VIOLATION">, z4.ZodLiteral<"PLAN_FORBIDDEN">, z4.ZodLiteral<"INTEGRATION_ERROR">, z4.ZodLiteral<"TOKEN_AUTH_USER">]>;
             type: z4.ZodDefault<z4.ZodOptional<z4.ZodDefault<z4.ZodUnion<readonly [z4.ZodLiteral<"success">, z4.ZodLiteral<"warning">, z4.ZodLiteral<"error">]>>>>;
             message: z4.ZodOptional<z4.ZodString>;
             results: z4.ZodAny;
@@ -28,6 +28,7 @@ declare namespace TypeControllerResponse {
         const FileResponseParamsSchema: z4.ZodObject<{
             status: z4.ZodUnion<readonly [z4.ZodLiteral<200>, z4.ZodLiteral<201>, z4.ZodLiteral<202>, z4.ZodLiteral<204>, z4.ZodLiteral<400>, z4.ZodLiteral<401>, z4.ZodLiteral<403>, z4.ZodLiteral<404>, z4.ZodLiteral<409>, z4.ZodLiteral<422>, z4.ZodLiteral<500>, z4.ZodLiteral<428>, z4.ZodLiteral<405>]>;
             message: z4.ZodOptional<z4.ZodString>;
+            fn: z4.ZodString;
             file_buffer: z4.ZodUnion<readonly [z4.ZodCustom<Blob, Blob>, z4.ZodCustom<ArrayBuffer, ArrayBuffer>, z4.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>;
             content_type: z4.ZodString;
             filename: z4.ZodOptional<z4.ZodString>;
@@ -41,9 +42,8 @@ declare namespace TypeControllerResponse {
             message: z4.ZodOptional<z4.ZodString>;
             results: z4.ZodOptional<z4.ZodUnion<readonly [z4.ZodArray<z4.ZodUnknown>, z4.ZodUnknown]>>;
             type: z4.ZodDefault<z4.ZodOptional<z4.ZodDefault<z4.ZodUnion<readonly [z4.ZodLiteral<"success">, z4.ZodLiteral<"warning">, z4.ZodLiteral<"error">]>>>>;
-            code: z4.ZodUnion<readonly [z4.ZodLiteral<"SUCCESS">, z4.ZodLiteral<"ACTION_REQUIRED">, z4.ZodLiteral<"CREATED">, z4.ZodLiteral<"WARNING">, z4.ZodLiteral<"AUTHORIZATION_ERROR">, z4.ZodLiteral<"SCHEMA_VALIDATION">, z4.ZodLiteral<"SERVER_ERROR">, z4.ZodLiteral<"UNAUTHORIZED">, z4.ZodLiteral<"INVALID_TOKEN">, z4.ZodLiteral<"NOT_FOUND">, z4.ZodLiteral<"SUCCESS_FILE">, z4.ZodLiteral<"DATABASE_ERROR">, z4.ZodLiteral<"BUSINESS_RULE_VIOLATION">, z4.ZodLiteral<"PLAN_FORBIDDEN">, z4.ZodLiteral<"INTEGRATION_ERROR">]>;
+            code: z4.ZodUnion<readonly [z4.ZodLiteral<"SUCCESS">, z4.ZodLiteral<"ACTION_REQUIRED">, z4.ZodLiteral<"CREATED">, z4.ZodLiteral<"WARNING">, z4.ZodLiteral<"ERROR">, z4.ZodLiteral<"AUTHORIZATION_ERROR">, z4.ZodLiteral<"SCHEMA_VALIDATION">, z4.ZodLiteral<"SERVER_ERROR">, z4.ZodLiteral<"UNAUTHORIZED">, z4.ZodLiteral<"INVALID_TOKEN">, z4.ZodLiteral<"NOT_FOUND">, z4.ZodLiteral<"SUCCESS_FILE">, z4.ZodLiteral<"DATABASE_ERROR">, z4.ZodLiteral<"BUSINESS_RULE_VIOLATION">, z4.ZodLiteral<"PLAN_FORBIDDEN">, z4.ZodLiteral<"INTEGRATION_ERROR">, z4.ZodLiteral<"TOKEN_AUTH_USER">]>;
             status: z4.ZodDefault<z4.ZodOptional<z4.ZodNumber>>;
-            fn: z4.ZodOptional<z4.ZodString>;
         }, z4.core.$strip>;
         type Input<T = unknown> = z4.infer<typeof InputSchema> & {
             results?: T;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@navservice/core",
-    "version": "1.116.0",
+    "version": "1.120.0",
     "description": "Service core de todos os micro serviços",
     "type": "module",
     "exports": {