@navservice/core 1.25.0 → 1.30.0

package/build/lib/helpers.cjs

@@ -0,0 +1,437 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+;
+// The require scope
+var __webpack_require__ = {};
+
+// webpack/runtime/compat_get_default_export
+(() => {
+// getDefaultExport function for compatibility with non-ESM modules
+__webpack_require__.n = (module) => {
+	var getter = module && module.__esModule ?
+		() => (module['default']) :
+		() => (module);
+	__webpack_require__.d(getter, { a: getter });
+	return getter;
+};
+
+})();
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "default": () => (/* binding */ src_helpers)
+});
+
+;// CONCATENATED MODULE: external "zod/v4"
+const v4_namespaceObject = require("zod/v4");
+var v4_default = /*#__PURE__*/__webpack_require__.n(v4_namespaceObject);
+;// CONCATENATED MODULE: ./src/helpers/_set_response.ts
+// TYPES
+
+const set_response = class set_response {
+    static c = class c {
+        static SUCCESS({ message, results, c }) {
+            const payload = {
+                status: 200,
+                code: "SUCCESS",
+                type: "success",
+                message: message || "Realizado com sucesso!",
+                results: results || []
+            };
+            if (c) {
+                return c.json(payload, {
+                    status: 200
+                });
+            }
+            return payload;
+        }
+        static ACTION_REQUIRED({ message, results, c }) {
+            const payload = {
+                status: 428,
+                code: "ACTION_REQUIRED",
+                type: "warning",
+                message: message || "Ação adicional necessária!",
+                results: results || []
+            };
+            if (c) {
+                return c.json(payload, {
+                    status: 428
+                });
+            }
+            return payload;
+        }
+        static CREATED({ message, results, c }) {
+            const payload = {
+                status: 201,
+                code: "CREATED",
+                type: "success",
+                message: message || "Criado com sucesso!",
+                results: results || []
+            };
+            return c ? c.json(payload, {
+                status: 201
+            }) : payload;
+        }
+        static WARNING({ message, results, c }) {
+            const payload = {
+                status: 400,
+                code: "WARNING",
+                type: "warning",
+                message: message || "Aviso!",
+                results: results || []
+            };
+            if (c) c.json(payload, {
+                status: 400
+            });
+            throw payload;
+        }
+        static AUTHORIZATION_ERROR({ message, results, c }) {
+            const payload = {
+                status: 405,
+                code: "WARNING",
+                type: "warning",
+                message: message || "Aviso!",
+                results: results || []
+            };
+            if (c) c.json(payload, {
+                status: 405
+            });
+            throw payload;
+        }
+        static DATABASE_ERROR({ message, results, c }) {
+            const payload = {
+                status: 500,
+                code: "DATABASE_ERROR",
+                type: "error",
+                message: message || "Erro no banco de dados!",
+                results: results || []
+            };
+            return c ? c.json(payload, {
+                status: 500
+            }) : payload;
+        }
+        static SERVER_ERROR({ error, c }) {
+            if (error instanceof (v4_default()).ZodError) {
+                const payload = {
+                    status: 500,
+                    code: "SCHEMA_VALIDATION",
+                    type: "warning",
+                    message: "Erro ao validar dados!",
+                    results: v4_default().treeifyError(error)
+                };
+                return c.json(payload, {
+                    status: 500
+                });
+            }
+            const payload = {
+                status: error?.status || 500,
+                code: error?.code || "SERVER_ERROR",
+                type: error?.type || "error",
+                message: error?.message || "Erro interno no servidor!",
+                results: error?.results || []
+            };
+            return c.json(payload, {
+                status: error?.status || error?.status || 500
+            });
+        }
+        static UNAUTHORIZED({ message, c }) {
+            const payload = {
+                status: 401,
+                code: "UNAUTHORIZED",
+                type: "error",
+                message: message || "Não autorizado!",
+                results: []
+            };
+            return c ? c.json(payload, {
+                status: 401
+            }) : payload;
+        }
+        static INVALID_TOKEN({ message, c }) {
+            const payload = {
+                status: 401,
+                code: "INVALID_TOKEN",
+                type: "warning",
+                message: message || "Token inválido!",
+                results: []
+            };
+            return c ? c.json(payload, {
+                status: 401
+            }) : payload;
+        }
+        static NOT_FOUND({ message, c }) {
+            const payload = {
+                status: 404,
+                code: "NOT_FOUND",
+                type: "error",
+                message: message || "Recurso não encontrado!",
+                results: []
+            };
+            return c ? c.json(payload, {
+                status: 404
+            }) : payload;
+        }
+        static async SUCCESS_FILE({ message, file_buffer, content_type, filename, c }) {
+            if (c && content_type) {
+                const headers = {
+                    "Content-Type": content_type,
+                    "Content-Disposition": filename ? `inline; filename="${filename}"` : "inline"
+                };
+                return new Response(file_buffer, {
+                    status: 200,
+                    headers
+                });
+            }
+            const payload = {
+                status: 200,
+                code: "SUCCESS_FILE",
+                type: "success",
+                message: message || "Erro ao retornar arquivo!",
+                results: []
+            };
+            return c ? c.json(payload, {
+                status: 200
+            }) : payload;
+        }
+    };
+    static error = class error {
+        static ACTION_REQUIRED({ message, results }) {
+            const payload = {
+                status: 428,
+                code: "ACTION_REQUIRED",
+                type: "warning",
+                message: message || "Ação adicional necessária!",
+                results: results || []
+            };
+            throw payload;
+        }
+        static WARNING({ message, results }) {
+            const payload = {
+                status: 400,
+                code: "WARNING",
+                type: "warning",
+                message: message || "Aviso!",
+                results: results || []
+            };
+            throw payload;
+        }
+        static AUTHORIZATION_ERROR({ message, results }) {
+            const payload = {
+                status: 400,
+                code: "WARNING",
+                type: "warning",
+                message: message || "Aviso!",
+                results: results || []
+            };
+            throw payload;
+        }
+        static DATABASE_ERROR({ message, results }) {
+            const payload = {
+                status: 405,
+                code: "DATABASE_ERROR",
+                type: "error",
+                message: message || "Erro no banco de dados!",
+                results: results || []
+            };
+            throw payload;
+        }
+        static SCHEMA_VALIDATION({ results }) {
+            const payload = {
+                status: 500,
+                code: "SCHEMA_VALIDATION",
+                type: "error",
+                message: "Erro ao validar dados!",
+                results: results || []
+            };
+            throw payload;
+        }
+        static UNAUTHORIZED({ message }) {
+            const payload = {
+                status: 401,
+                code: "UNAUTHORIZED",
+                type: "error",
+                message: message || "Não autorizado!"
+            };
+            throw payload;
+        }
+        static INVALID_TOKEN({ message }) {
+            const payload = {
+                status: 401,
+                code: "INVALID_TOKEN",
+                type: "warning",
+                message: message || "Token inválido!",
+                results: []
+            };
+            throw payload;
+        }
+        static NOT_FOUND({ message }) {
+            const payload = {
+                status: 404,
+                code: "NOT_FOUND",
+                type: "error",
+                message: message || "Recurso não encontrado!"
+            };
+            throw payload;
+        }
+    };
+};
+/* export default */ const _set_response = (set_response);
+
+;// CONCATENATED MODULE: external "jose"
+const external_jose_namespaceObject = require("jose");
+;// CONCATENATED MODULE: ./src/helpers/_token.ts
+
+
+const _token = class _token {
+    static async verificar_token(c, next) {
+        try {
+            const authHeader = c.req.header("Authorization");
+            if (!authHeader) return src_helpers.set_response.c.INVALID_TOKEN({
+                message: 'token não enviado!!!',
+                c: c,
+                results: []
+            });
+            const token = authHeader.split(" ")[1];
+            if (!token) return src_helpers.set_response.c.INVALID_TOKEN({
+                message: 'Acesso negado!!!',
+                c: c,
+                results: []
+            });
+            const secret = new TextEncoder().encode(c.env.JSON_WEB_TOKEN_AUTH_USER);
+            const { payload } = await external_jose_namespaceObject.jwtVerify(token, secret);
+            if (!payload._id || !payload.email) {
+                return src_helpers.set_response.c.INVALID_TOKEN({
+                    message: 'Token inválido!!!!',
+                    c: c,
+                    results: []
+                });
+            }
+            const setar_token = {
+                _id: payload._id,
+                email: payload.email,
+                ativo: payload.ativo,
+                data_criacao: payload.data_criacao,
+                nome: payload.nome,
+                app: payload.app,
+                usuario_tipo: payload.usuario_tipo
+            };
+            c.set("usuario_auth", setar_token);
+            return await next();
+        } catch (error) {
+            return src_helpers.set_response.c.INVALID_TOKEN({
+                message: 'Token inválido!!!',
+                c: c,
+                results: []
+            });
+        }
+    }
+    static async criar_token_login_usuario({ _id, email, app, usuario_tipo, ativo, data_criacao, nome, c }) {
+        if (!c.env.JSON_WEB_TOKEN_AUTH_USER) {
+            return src_helpers.set_response.error.WARNING({
+                message: "Erro ao gerar token!!",
+                results: []
+            });
+        }
+        const token = await new external_jose_namespaceObject.SignJWT({
+            _id: _id,
+            email: email,
+            app: app,
+            usuario_tipo: usuario_tipo,
+            ativo: ativo,
+            data_criacao: data_criacao,
+            nome: nome
+        }).setProtectedHeader({
+            alg: "HS256"
+        }).setIssuedAt()//.setExpirationTime("24h")
+        .sign(new TextEncoder().encode(c.env.JSON_WEB_TOKEN_AUTH_USER)).catch((error)=>{
+            return src_helpers.set_response.error.WARNING({
+                message: "Erro ao gerar token!",
+                results: error?.message
+            });
+        });
+        return token;
+    }
+};
+/* export default */ const helpers_token = (_token);
+
+;// CONCATENATED MODULE: external "node:crypto"
+const external_node_crypto_namespaceObject = require("node:crypto");
+;// CONCATENATED MODULE: external "node:util"
+const external_node_util_namespaceObject = require("node:util");
+;// CONCATENATED MODULE: ./src/helpers/_secret.ts
+
+
+const scryptAsync = (0,external_node_util_namespaceObject.promisify)(external_node_crypto_namespaceObject.scrypt);
+class _secret {
+    static SALT_LENGTH = 22;
+    static KEY_LENGTH = 35;
+    static async gerar_hash_senha(password) {
+        const salt = (0,external_node_crypto_namespaceObject.randomBytes)(this.SALT_LENGTH);
+        const derivedKey = await scryptAsync(password, salt, this.KEY_LENGTH);
+        return salt.toString('base64') + '.' + derivedKey.toString('base64');
+    }
+    static async verify({ password, dashed_senha }) {
+        try {
+            const [saltBase64, hashBase64] = dashed_senha.split('.');
+            if (!saltBase64 || !hashBase64) return false;
+            const salt = Buffer.from(saltBase64, 'base64');
+            const storedHash = Buffer.from(hashBase64, 'base64');
+            const derivedKey = await scryptAsync(password, salt, this.KEY_LENGTH);
+            return (0,external_node_crypto_namespaceObject.timingSafeEqual)(storedHash, derivedKey);
+        } catch  {
+            return false;
+        }
+    }
+}
+/* export default */ const helpers_secret = (_secret);
+
+;// CONCATENATED MODULE: ./src/helpers/index.ts
+//_HELPERS
+
+
+
+class helpers {
+    static set_response = _set_response;
+    static token = helpers_token;
+    static secret = helpers_secret;
+}
+/* export default */ const src_helpers = (helpers);
+
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__) {
+  if(["default"].indexOf(__rspack_i) === -1) {
+    exports[__rspack_i] = __webpack_exports__[__rspack_i];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });