@navservice/usuario 1.53.0 → 1.56.0

package/build/es/backend/schema/schema_usuario.d.ts

@@ -0,0 +1,220 @@
+import { InferInsertModel, InferSelectModel } from 'drizzle-orm';
+export declare const schema_usuario: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "usuario";
+    schema: undefined;
+    columns: {
+        _id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "_id";
+            tableName: "usuario";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        data_criacao: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "data_criacao";
+            tableName: "usuario";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        data_atualizacao: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "data_atualizacao";
+            tableName: "usuario";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        data_exclusao: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "data_exclusao";
+            tableName: "usuario";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        nome: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "nome";
+            tableName: "usuario";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        email: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "email";
+            tableName: "usuario";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        senha: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "senha";
+            tableName: "usuario";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        imagem: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "imagem";
+            tableName: "usuario";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        auth_google: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "auth_google";
+            tableName: "usuario";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: 0 | 1;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: 0 | 1;
+        }>;
+        excluido: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "excluido";
+            tableName: "usuario";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: 0 | 1;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: 0 | 1;
+        }>;
+        ativo: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "ativo";
+            tableName: "usuario";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: 0 | 1;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: 0 | 1;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+export type Base = InferSelectModel<typeof schema_usuario>;
+export type Criar = InferInsertModel<typeof schema_usuario>;
+export type BuscarPeloFiltro = Partial<Pick<InferSelectModel<typeof schema_usuario>, "_id" | "nome" | "email" | "ativo" | "excluido">> & {
+    pagina: number;
+};
+export type AtualizarPeloId = Pick<InferSelectModel<typeof schema_usuario>, "_id"> & Partial<Pick<InferSelectModel<typeof schema_usuario>, "nome" | "email" | "senha" | "imagem" | "auth_google" | "ativo" | "excluido" | "data_atualizacao">>;
+export type BuscarPeloId = Pick<InferSelectModel<typeof schema_usuario>, "_id">;
+export type DeletarPeloId = Pick<InferSelectModel<typeof schema_usuario>, "_id">;
+export default schema_usuario;

package/build/es/biblioteca/src/componentes/auth/RefreshToken/RefreshToken.d.ts

@@ -3,5 +3,5 @@ interface TypeRefreshToken {
     app: TypesCore.Controller.Usuario.TokenPayload["app"];
     usuario_tipo: TypesCore.Controller.Usuario.TokenPayload["usuario_tipo"];
 }
-export declare function RefreshToken(props: TypeRefreshToken): import("react/jsx-runtime").JSX.Element;
+export declare function RefreshToken({ app, usuario_tipo }: TypeRefreshToken): import("react/jsx-runtime").JSX.Element;
 export {};

package/build/es/index.js

@@ -2196,13 +2196,15 @@ const lib_axios = axios;
         "FREE",
         "ESSENTIAL",
         "BUSINESS",
-        "ULTIMATE"
+        "ENTERPRISE"
     ];
     TypeControllerUsuario.AppEnum = [
         "service-usuario",
         "service-pages",
         "service-assinatura",
-        "service-bucket"
+        "service-bucket",
+        "service-galio",
+        "service-oraculo"
     ];
     TypeControllerUsuario.AssinaturaStatusEnum = [
         "active",
@@ -2227,6 +2229,12 @@ const lib_axios = axios;
         "service-pages": [
             "padrao"
         ],
+        "service-galio": [
+            "padrao"
+        ],
+        "service-oraculo": [
+            "padrao"
+        ],
         "service-bucket": [
             "padrao"
         ]
@@ -2271,7 +2279,11 @@ var _usuario_TypeControllerUsuario;
         v4.literal("INVALID_TOKEN"),
         v4.literal("NOT_FOUND"),
         v4.literal("SUCCESS_FILE"),
-        v4.literal("DATABASE_ERROR")
+        v4.literal("DATABASE_ERROR"),
+        v4.literal("BUSINESS_RULE_VIOLATION"),
+        v4.literal("PLAN_FORBIDDEN"),
+        v4.literal("INTEGRATION_ERROR"),
+        v4.literal("TOKEN_AUTH_USER")
     ]);
     v4.object({
         status: StatusSchema,
@@ -2293,6 +2305,7 @@ var _usuario_TypeControllerUsuario;
         v4.object({
             status: StatusSchema,
             message: v4.string().optional(),
+            fn: v4.string(),
             file_buffer: v4.union([
                 v4["instanceof"](Blob),
                 v4["instanceof"](ArrayBuffer),
@@ -2884,6 +2897,39 @@ class _hooks {
             localStorage.setItem("theme", "light");
         }
     }
+    use_set_show_component() {
+        function aplicarVisibilidadeElemento(el) {
+            const valor = el.getAttribute("set-show-component");
+            if ("ocultar" === valor) el.style.display = "none";
+            else if ("exibir" === valor) el.style.display = "";
+        }
+        function aplicarVisibilidade(node = document) {
+            const elementos = node.querySelectorAll("[set-show-component]");
+            elementos.forEach(aplicarVisibilidadeElemento);
+        }
+        document.addEventListener("DOMContentLoaded", ()=>{
+            aplicarVisibilidade();
+            const observer = new MutationObserver((mutations)=>{
+                mutations.forEach((mutation)=>{
+                    mutation.addedNodes.forEach((node)=>{
+                        if (node instanceof HTMLElement) {
+                            if (node.hasAttribute("set-show-component")) aplicarVisibilidadeElemento(node);
+                            aplicarVisibilidade(node);
+                        }
+                    });
+                    if ("attributes" === mutation.type && mutation.target instanceof HTMLElement && "set-show-component" === mutation.attributeName) aplicarVisibilidadeElemento(mutation.target);
+                });
+            });
+            observer.observe(document.body, {
+                childList: true,
+                subtree: true,
+                attributes: true,
+                attributeFilter: [
+                    "set-show-component"
+                ]
+            });
+        });
+    }
 }
 const utils_hooks = new _hooks;
 const _environment = class {
@@ -2931,7 +2977,8 @@ const type_controller_usuario_input = (meta)=>JSON.stringify(meta);
         ativo: v4.union([
             v4.literal(0),
             v4.literal(1)
-        ])
+        ]),
+        imagem: v4.string()
     });
     (function(Register) {
         Register.route = "/api/usuario/auth/register";
@@ -3154,7 +3201,7 @@ var type_controller_authenticator_TypeControlerAutheticator;
         })
     });
     (function(EnviarCodigoOtp) {
-        EnviarCodigoOtp.route = "/usuario/auth/enviar_codigo_verificacao_otp";
+        EnviarCodigoOtp.route = "/api/usuario/auth/enviar_codigo_verificacao_otp";
         EnviarCodigoOtp.InputSchema = v4.object({
             data: v4.object({
                 codigo_verificacao_otp: v4.object({
@@ -3179,7 +3226,7 @@ var type_controller_authenticator_TypeControlerAutheticator;
         });
     })(TypeControllerCodigoOtp.EnviarCodigoOtp || (TypeControllerCodigoOtp.EnviarCodigoOtp = {}));
     (function(EntrarComCodigoOtp) {
-        EntrarComCodigoOtp.route = "/usuario/auth/entrar_com_codigo_otp";
+        EntrarComCodigoOtp.route = "/api/usuario/auth/entrar_com_codigo_otp";
         EntrarComCodigoOtp.InputSchema = v4.object({
             data: v4.object({
                 codigo_verificacao_otp: v4.object({
@@ -7891,63 +7938,31 @@ const VerificarAuthenticator = ()=>{
     });
 };
 const REFRESH_INTERVAL = 3300000;
-const REFRESH_STORAGE_KEY = "last_refresh_token_at";
-const REFRESH_LOCK_KEY = "refresh_token_lock";
-const LOCK_DURATION = 10000;
-function RefreshToken_RefreshToken(props) {
+function RefreshToken_RefreshToken({ app, usuario_tipo }) {
     const isRefreshingRef = useRef(false);
-    const intervalRef = useRef(null);
-    function getSafeTimestamp(key) {
-        const value1 = src_utils.session_sorage.get_item_session_storage(key);
-        return value1 && !isNaN(Number(value1)) ? Number(value1) : 0;
-    }
-    function setSafeTimestamp(key, value1) {
-        src_utils.session_sorage.set_session_storage_sem_incremento({
-            chave: key,
-            novoItem: value1.toString()
-        });
-    }
-    function checkAuthentication() {
-        const usuario = src_utils.session_sorage.usuario_auth;
-        if (!usuario?.data?.usuario?._id || !usuario?.data?.usuario?.refresh_token) {
-            contexto_contexto_usuario.contexto.state.set_signout();
-            return false;
-        }
-        return true;
-    }
     async function handleRefreshToken() {
-        if (!checkAuthentication() || isRefreshingRef.current) return;
+        if (isRefreshingRef.current) return;
+        const usuario = src_utils.session_sorage.usuario_auth?.data?.usuario;
+        if (!usuario?._id || !usuario?.refresh_token) return void contexto_contexto_usuario.contexto.state.set_signout();
+        isRefreshingRef.current = true;
         try {
-            const usuario = src_utils.session_sorage.usuario_auth?.data?.usuario;
-            const now = Date.now();
-            const lastRefresh = getSafeTimestamp(REFRESH_STORAGE_KEY);
-            const lock = getSafeTimestamp(REFRESH_LOCK_KEY);
-            if (lastRefresh && now - lastRefresh < REFRESH_INTERVAL) return;
-            if (lock && now - lock < LOCK_DURATION) return;
-            setSafeTimestamp(REFRESH_LOCK_KEY, now);
-            isRefreshingRef.current = true;
-            const response = await contexto_contexto_usuario.api.refresh_token({
+            await contexto_contexto_usuario.api.refresh_token({
                 data: {
                     usuario: {
-                        app: props.app,
-                        usuario_tipo: props.usuario_tipo,
+                        app,
+                        usuario_tipo,
                         refresh_token: usuario.refresh_token
                     }
                 }
             });
-            if (response?.data?.status === 200) setSafeTimestamp(REFRESH_STORAGE_KEY, now);
         } finally{
             isRefreshingRef.current = false;
-            setSafeTimestamp(REFRESH_LOCK_KEY, 0);
         }
     }
     useEffect(()=>{
-        if (!checkAuthentication()) return;
         handleRefreshToken();
-        intervalRef.current = setInterval(handleRefreshToken, REFRESH_INTERVAL);
-        return ()=>{
-            if (intervalRef.current) clearInterval(intervalRef.current);
-        };
+        const interval = setInterval(handleRefreshToken, REFRESH_INTERVAL);
+        return ()=>clearInterval(interval);
     }, []);
     return /*#__PURE__*/ jsx(Fragment, {});
 }

package/build/es/shared/types/controller/type_codigo_verificacao_otp.d.ts

@@ -10,7 +10,7 @@ declare namespace TypeControllerCodigoOtp {
         codigo: z4.ZodString;
     }, z4.core.$strip>;
     namespace EnviarCodigoOtp {
-        const route: "/usuario/auth/enviar_codigo_verificacao_otp";
+        const route: "/api/usuario/auth/enviar_codigo_verificacao_otp";
         const InputSchema: z4.ZodObject<{
             data: z4.ZodObject<{
                 codigo_verificacao_otp: z4.ZodObject<{
@@ -35,7 +35,7 @@ declare namespace TypeControllerCodigoOtp {
         type Response = AxiosResponse<t.Geral.Response.C.Output<Output>>;
     }
     namespace EntrarComCodigoOtp {
-        const route: "/usuario/auth/entrar_com_codigo_otp";
+        const route: "/api/usuario/auth/entrar_com_codigo_otp";
         const InputSchema: z4.ZodObject<{
             data: z4.ZodObject<{
                 codigo_verificacao_otp: z4.ZodObject<{
@@ -49,6 +49,8 @@ declare namespace TypeControllerCodigoOtp {
                         "service-pages": "service-pages";
                         "service-assinatura": "service-assinatura";
                         "service-bucket": "service-bucket";
+                        "service-galio": "service-galio";
+                        "service-oraculo": "service-oraculo";
                     }>;
                 }, z4.core.$strip>;
             }, z4.core.$strip>;

package/build/es/shared/types/controller/type_controller_usuario.d.ts

@@ -15,6 +15,7 @@ declare namespace TypeControllerUsuario {
         auth_google: z4.ZodUnion<readonly [z4.ZodLiteral<0>, z4.ZodLiteral<1>]>;
         excluido: z4.ZodUnion<readonly [z4.ZodLiteral<0>, z4.ZodLiteral<1>]>;
         ativo: z4.ZodUnion<readonly [z4.ZodLiteral<0>, z4.ZodLiteral<1>]>;
+        imagem: z4.ZodString;
     }, z4.core.$strip>;
     type UsuarioBase = z4.infer<typeof UsuarioBaseSchema>;
     export namespace Register {
@@ -35,6 +36,8 @@ declare namespace TypeControllerUsuario {
                         "service-pages": "service-pages";
                         "service-assinatura": "service-assinatura";
                         "service-bucket": "service-bucket";
+                        "service-galio": "service-galio";
+                        "service-oraculo": "service-oraculo";
                     }>;
                 }, z4.core.$strip>;
             }, z4.core.$strip>;
@@ -57,6 +60,8 @@ declare namespace TypeControllerUsuario {
                         "service-pages": "service-pages";
                         "service-assinatura": "service-assinatura";
                         "service-bucket": "service-bucket";
+                        "service-galio": "service-galio";
+                        "service-oraculo": "service-oraculo";
                     }>;
                     codigo_temporario: z4.ZodOptional<z4.ZodNullable<z4.ZodString>>;
                 }, z4.core.$strip>;
@@ -82,6 +87,8 @@ declare namespace TypeControllerUsuario {
                         "service-pages": "service-pages";
                         "service-assinatura": "service-assinatura";
                         "service-bucket": "service-bucket";
+                        "service-galio": "service-galio";
+                        "service-oraculo": "service-oraculo";
                     }>;
                 }, z4.core.$strip>;
             }, z4.core.$strip>;
@@ -104,6 +111,8 @@ declare namespace TypeControllerUsuario {
                         "service-pages": "service-pages";
                         "service-assinatura": "service-assinatura";
                         "service-bucket": "service-bucket";
+                        "service-galio": "service-galio";
+                        "service-oraculo": "service-oraculo";
                     }>;
                 }, z4.core.$strip>;
             }, z4.core.$strip>;

package/build/es/shared/types/index.d.ts

@@ -44,6 +44,7 @@ declare namespace t {
         };
         Variables: {
             usuario_auth: TypesCore.Controller.Usuario.TokenPayload;
+            token: string;
         };
     };
     type Context = HonoContext<Env>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@navservice/usuario",
-    "version": "1.53.0",
+    "version": "1.56.0",
     "description": "Service de autenticação de usuários unificado",
     "type": "module",
     "main": "./build/lib/index.js",