@navservice/core 1.115.0 → 1.119.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",
@@ -120,11 +120,17 @@ const set_response = new class set_response {
                 message: message || "Realizado com sucesso!",
                 results: results || []
             };
+            helpers_logger.add({
+                fn: `${fn}_SUCCESS`,
+                level: "info",
+                message: payload?.message,
+                results: payload?.results
+            });
             return c.json(payload, {
                 status: 200
             });
         }
-        ACTION_REQUIRED({ message, results, c }) {
+        ACTION_REQUIRED({ message, results, c, fn }) {
             const payload = {
                 status: 428,
                 code: "ACTION_REQUIRED",
@@ -132,11 +138,17 @@ const set_response = new class set_response {
                 message: message || "Ação adicional necessária!",
                 results: results || []
             };
+            helpers_logger.add({
+                fn: `${fn}_ACTION_REQUIRED`,
+                level: "info",
+                message: payload?.message,
+                results: payload?.results
+            });
             return c.json(payload, {
                 status: 428
             });
         }
-        CREATED({ message, results, c }) {
+        CREATED({ message, results, c, fn }) {
             const payload = {
                 status: 201,
                 code: "CREATED",
@@ -144,11 +156,17 @@ const set_response = new class set_response {
                 message: message || "Criado com sucesso!",
                 results: results || []
             };
+            helpers_logger.add({
+                fn: `${fn}_CREATED`,
+                level: "info",
+                message: payload?.message,
+                results: payload?.results
+            });
             return c.json(payload, {
                 status: 201
             });
         }
-        WARNING({ message, results, c }) {
+        WARNING({ message, results, c, fn }) {
             const payload = {
                 status: 400,
                 code: "WARNING",
@@ -156,11 +174,17 @@ const set_response = new class set_response {
                 message: message || "Aviso!",
                 results: results || []
             };
+            helpers_logger.add({
+                fn: `${fn}_WARNING`,
+                level: "info",
+                message: payload?.message,
+                results: payload?.results
+            });
             return c.json(payload, {
                 status: 400
             });
         }
-        AUTHORIZATION_ERROR({ message, results, c }) {
+        AUTHORIZATION_ERROR({ message, results, c, fn }) {
             const payload = {
                 status: 405,
                 code: "WARNING",
@@ -168,11 +192,17 @@ const set_response = new class set_response {
                 message: message || "Aviso!",
                 results: results || []
             };
+            helpers_logger.add({
+                fn: `${fn}_AUTHORIZATION_ERROR`,
+                level: "error",
+                message: payload?.message,
+                results: payload?.results
+            });
             return c.json(payload, {
                 status: 405
             });
         }
-        SERVER_ERROR({ error, c }) {
+        SERVER_ERROR({ error, c, fn }) {
             if (error instanceof (v4_default()).ZodError) {
                 const payload = {
                     status: 500,
@@ -182,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
@@ -200,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
@@ -210,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",
@@ -218,11 +248,17 @@ const set_response = new class set_response {
                 message: message || "Não autorizado!",
                 results: []
             };
+            helpers_logger.add({
+                fn: `${fn}_UNAUTHORIZED`,
+                level: "error",
+                message: payload?.message,
+                results: payload?.results
+            });
             return c.json(payload, {
                 status: 401
             });
         }
-        INVALID_TOKEN({ message, c }) {
+        INVALID_TOKEN({ message, c, fn }) {
             const payload = {
                 status: 409,
                 code: "INVALID_TOKEN",
@@ -230,11 +266,17 @@ const set_response = new class set_response {
                 message: message || "Token inválido!",
                 results: []
             };
+            helpers_logger.add({
+                fn: `${fn}_INVALID_TOKEN`,
+                level: "error",
+                message: payload?.message,
+                results: payload?.results
+            });
             return c.json(payload, {
                 status: 409
             });
         }
-        NOT_FOUND({ message, c }) {
+        NOT_FOUND({ message, c, fn }) {
             const payload = {
                 status: 404,
                 code: "NOT_FOUND",
@@ -242,16 +284,28 @@ const set_response = new class set_response {
                 message: message || "Recurso não encontrado!",
                 results: []
             };
+            helpers_logger.add({
+                fn: `${fn}_NOT_FOUND`,
+                level: "info",
+                message: payload?.message,
+                results: payload?.results
+            });
             return c.json(payload, {
                 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: `${fn}_SUCCESS_FILE`,
+                    level: "info",
+                    message: "",
+                    results: headers
+                });
                 return c.json(file_buffer, {
                     status: 200,
                     headers
@@ -264,13 +318,19 @@ const set_response = new class set_response {
                 message: message || "Erro ao retornar arquivo!",
                 results: []
             };
+            helpers_logger.add({
+                fn: `${fn}_SUCCESS_FILE`,
+                level: "info",
+                message: payload?.message,
+                results: payload?.results
+            });
             return c.json(payload, {
                 status: 200
             });
         }
     };
     error = new class error {
-        ACTION_REQUIRED({ message, results }) {
+        ACTION_REQUIRED({ message, results, fn }) {
             const payload = {
                 status: 428,
                 code: "ACTION_REQUIRED",
@@ -278,9 +338,15 @@ const set_response = new class set_response {
                 message: message || "Ação adicional necessária!",
                 results: results || []
             };
+            helpers_logger.add({
+                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",
@@ -288,9 +354,31 @@ const set_response = new class set_response {
                 message: message || "Aviso!",
                 results: results || []
             };
+            helpers_logger.add({
+                fn: `${fn}_WARNING`,
+                level: "info",
+                message: payload?.message,
+                results: payload?.results
+            });
             throw payload;
         }
-        AUTHORIZATION_ERROR({ message, results }) {
+        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",
@@ -298,9 +386,16 @@ const set_response = new class set_response {
                 message: message || "Aviso!",
                 results: results || []
             };
+            helpers_logger.add({
+                fn: `${fn}_AUTHORIZATION_ERROR`,
+                level: "error",
+                message: payload?.message,
+                results: payload?.results
+            });
             throw payload;
         }
-        DATABASE_ERROR({ message, erro }) {
+        // CONTEM _LOGGER PARA FACILITAR OS LOGS DE TRACING DO SISTEMA
+        DATABASE_ERROR({ message, erro, fn }) {
             const errorCode = erro?.cause?.code || erro?.cause?.cause?.code || erro?.code || "";
             const map = {
                 "SQLITE_CONSTRAINT_UNIQUE": {
@@ -344,14 +439,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",
@@ -359,37 +454,78 @@ const set_response = new class set_response {
                 message: "Erro ao validar dados!",
                 results: results || []
             };
+            helpers_logger.add({
+                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",
                 type: "error",
                 message: message || "Não autorizado!"
             };
+            helpers_logger.add({
+                fn: `${fn}_UNAUTHORIZED`,
+                level: "error",
+                message: payload?.message,
+                results: payload?.results
+            });
             throw payload;
         }
-        INVALID_TOKEN({ message }) {
+        INTEGRATION_ERROR({ message, fn, erro }) {
+            const payload = {
+                status: 401,
+                code: "INTEGRATION_ERROR",
+                type: "error",
+                message: message || "Erro na camada de integração!",
+                results: erro
+            };
+            helpers_logger.add({
+                fn: `${fn}_INTEGRATION_ERROR`,
+                level: "error",
+                message: payload?.message,
+                results: erro
+            });
+            throw payload;
+        }
+        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: `${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: `${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",
@@ -397,9 +533,15 @@ const set_response = new class set_response {
                 message: message || "Limite atingido ou regra de negócio violada!",
                 results: results || []
             };
+            helpers_logger.add({
+                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",
@@ -407,6 +549,12 @@ const set_response = new class set_response {
                 message: message || "Plano inativo ou sem permissão para esta ação!",
                 results: results || []
             };
+            helpers_logger.add({
+                fn: `${fn}_PLAN_FORBIDDEN`,
+                level: "info",
+                message: payload?.message,
+                results: payload?.results
+            });
             throw payload;
         }
     };
@@ -419,6 +567,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 {
@@ -426,13 +575,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);
@@ -440,7 +591,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 = {
@@ -461,15 +613,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({
@@ -485,9 +639,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;
@@ -498,13 +653,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);
@@ -512,7 +669,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 = {
@@ -532,15 +690,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");
@@ -557,18 +717,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({
@@ -576,8 +738,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

@@ -153,7 +153,9 @@ var _usuario_TypeControllerUsuario;
         v4_default().literal("SUCCESS_FILE"),
         v4_default().literal("DATABASE_ERROR"),
         v4_default().literal("BUSINESS_RULE_VIOLATION"),
-        v4_default().literal("PLAN_FORBIDDEN")
+        v4_default().literal("PLAN_FORBIDDEN"),
+        v4_default().literal("INTEGRATION_ERROR"),
+        v4_default().literal("TOKEN_AUTH_USER")
     ]);
     const BaseResponseSchema = v4_default().object({
         status: StatusSchema,
@@ -175,6 +177,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),
@@ -194,8 +197,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">]>;
+        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">, 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">]>;
+            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">, 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">]>;
+            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">, 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.115.0",
+    "version": "1.119.0",
     "description": "Service core de todos os micro serviços",
     "type": "module",
     "exports": {