@jmlq/logger 0.1.0-alpha.2 → 0.1.0-alpha.21

package/README.md

@@ -0,0 +1,639 @@
+# @jmlq/logger
+
+Sistema de logging modular y extensible con **Arquitectura Limpia**. Soporta múltiples destinos (archivos, MongoDB, PostgreSQL) y enmascarado automático de datos sensibles (PII).
+
+Se encarga de:
+
+- Persistencia de logs en múltiples datasources
+- Enmascarado automático de datos sensibles (PII)
+- Filtros y búsquedas avanzadas
+- Arquitectura extensible y testeable
+
+## Componentes principales expuestos
+
+### Factory
+
+- **[`createLogger`](src/application/factory/logger.factory.ts)**  
+  Factory de alto nivel que construye un `ILogger` compatible con `@jmlq/logger`, resolviendo internamente:
+
+  - Configuración de datasources múltiples (fan-out)
+  - Inicialización del redactor PII
+  - Composición de casos de uso
+  - Nivel mínimo de logging
+
+  > Es el **único punto recomendado de entrada** para consumidores del paquete.
+
+---
+
+### Tipos de configuración
+
+- **[`ILoggerFactoryConfig`](src/application/types/logger-factory-config.type.ts)**  
+  Define la configuración necesaria:
+  - `datasources`: Uno o múltiples datasources donde persistir logs
+  - `minLevel`: Nivel mínimo de logging (por defecto INFO)
+  - `redactor`: Instancia personalizada de redactor PII
+  - `redactorOptions`: Configuración para redactor interno
+
+---
+
+## Contratos (Types / Ports)
+
+Estos tipos existen para **desacoplar el dominio y la aplicación**.  
+Son útiles para testing, extensiones avanzadas o integraciones personalizadas.
+
+- **[`ILogger`](src/domain/ports/logger.port.ts)**: Interfaz principal del logger con métodos por nivel
+- **[`ILogDatasource`](src/domain/ports/log-datasource.port.ts)**: Contrato para implementar datasources personalizados
+- **[`LogLevel`](src/domain/value-objects/log-level.vo.ts)**: Enumeración de niveles de logging
+- **[`LogFilterRequest`](src/domain/request/log-filter.request.ts)**: Filtros para consultas de logs
+- **[`ILogResponse`](src/domain/response/log.response.ts)**: Formato de respuesta de logs consultados
+- **[`PiiOptions`](src/domain/model/pii-options.model.ts)**: Configuración para enmascarado PII
+- **[`LogEntry`](src/domain/model/log-entry.model.ts)**: Modelo de entrada de log
+- **[`PiiRedactor`](src/domain/services/pii-redactor.service.ts)**: Servicio de enmascarado PII
+
+---
+
+## 📦 Instalación
+
+```bash
+# Core del logger
+npm install @jmlq/logger
+
+# Plugins opcionales (instala según necesites)
+npm install @jmlq/logger-plugin-fs        # Para archivos
+npm install @jmlq/logger-plugin-mongo     # Para MongoDB
+npm install @jmlq/logger-plugin-postgresql # Para PostgreSQL
+```
+
+---
+
+## Configuración @jmlq/logger
+
+### Variables de entorno
+
+Ver cómo se configuran los adapters de `@jmlq/logger-plugin-fs`, `@jmlq/logger-plugin-mongo` y `@jmlq/logger-plugin-postgresql`.
+
+| Plugin                           | Descripción                | NPM                                                             |
+| -------------------------------- | -------------------------- | --------------------------------------------------------------- |
+| `@jmlq/logger-plugin-fs`         | Persistencia en archivos   | [npm](https://npmjs.com/package/@jmlq/logger-plugin-fs)         |
+| `@jmlq/logger-plugin-mongo`      | Persistencia en MongoDB    | [npm](https://npmjs.com/package/@jmlq/logger-plugin-mongo)      |
+| `@jmlq/logger-plugin-postgresql` | Persistencia en PostgreSQL | [npm](https://npmjs.com/package/@jmlq/logger-plugin-postgresql) |
+
+El paquete no gestiona variables de entorno internamente, pero puedes implementar tu propia capa de configuración. Estas son las variables de entorno que se usan para configurar todos los plugins.
+
+```ini
+# Settings @jmlq/logger
+# LOGGER Plugins Configuration
+# Nivel mínimo de logs
+# Valores: TRACE, DEBUG, INFO, WARN, ERROR, FATAL
+LOG_LEVEL=INFO
+# PII Protection
+LOGGER_PII_ENABLED=true
+LOGGER_PII_INCLUDE_DEFAULTS=false
+# FS Plugin Settings
+LOGGER_FS_PATH=./logs/
+# MongoDB Plugin Settings
+LOGGER_MONGO_DB_URL=mongodb://root:secret@localhost:27018/?authSource=admin
+LOGGER_MONGO_DB_NAME=logger_example_db
+LOGGER_MONGO_COLLECTION_NAME=logs_datasource_factory_example
+# PostgreSQL Plugin Settings
+LOGGER_PG_CONNECTION_STRING=postgres://admin:secret@localhost:5436/logger_tests
+LOGGER_PG_TABLE_NAME=logs_example_factory
+LOGGER_PG_SCHEMA=public
+```
+
+### Interfaz de configuración del paquete
+
+```ts
+// Path Ejemplo: src/infrastructure/logger/core/logger.bootstrap.options.ts
+
+import { LogLevel } from "@jmlq/logger";
+import { IFilesystemDatasourceOptions } from "@jmlq/logger-plugin-fs";
+import { IMongoDatasourceOptions } from "@jmlq/logger-plugin-mongo";
+import { IPostgresDatasourceOptions } from "@jmlq/logger-plugin-postgresql";
+
+export interface LoggerBootstrapOptions {
+  minLevel: LogLevel;
+  pii?: {
+    enabled?: boolean;
+    whitelistKeys?: string[];
+    blacklistKeys?: string[];
+    patterns?: any[];
+    deep?: boolean;
+    includeDefaults?: boolean;
+  };
+  adapters?: {
+    // NOTA: Opcional, depende de las necesidades del cliente
+    fs?: IFilesystemDatasourceOptions;
+    mongo?: IMongoDatasourceOptions;
+    pg?: IPostgresDatasourceOptions;
+  };
+}
+```
+
+### Implementación del Logger
+
+```ts
+// Path Ejemplo: src/infrastructure/logger/core/logger.bootstrap.ts
+
+import { type ILogDatasource, createLogger } from "@jmlq/logger";
+import { FsAdapter } from "../fs/fs.adapter";
+import { MongoAdapter } from "../mongo/mongo.adapter";
+import { PgAdapter } from "../pg/pg.adapter";
+import { LoggerBootstrapOptions } from "./logger.bootstrap.options";
+
+export class LoggerBootstrap {
+  private constructor(
+    private readonly _logger: ReturnType<typeof createLogger>
+  ) {}
+
+  static async create(opts: LoggerBootstrapOptions): Promise<LoggerBootstrap> {
+    const dsList: ILogDatasource[] = [];
+
+    // NOTA: Opcional, depende de las necesidades del cliente
+    if (opts.adapters?.fs) {
+      const fs = FsAdapter.create(opts.adapters.fs);
+      if (fs) dsList.push(fs.datasource);
+    }
+    if (opts.adapters?.mongo) {
+      const mongo = await MongoAdapter.create(opts.adapters.mongo);
+      if (mongo) dsList.push(mongo.datasource);
+    }
+    if (opts.adapters?.pg) {
+      const pg = await PgAdapter.create(opts.adapters.pg);
+      if (pg) dsList.push(pg.datasource);
+    }
+    //----
+
+    if (dsList.length === 0)
+      throw new Error("[logger] No hay datasources válidos.");
+
+    const logger = createLogger({
+      datasources: dsList,
+      minLevel: opts.minLevel,
+      redactorOptions: {
+        enabled: opts.pii?.enabled ?? false,
+        deep: opts.pii?.deep ?? true,
+        patterns: opts.pii?.patterns ?? [],
+      },
+    });
+
+    console.log("✅ Logger creado correctamente.\n");
+
+    return new LoggerBootstrap(logger);
+  }
+
+  get logger() {
+    return this._logger;
+  }
+
+  // Limpia buffers pendientes antes del cierre
+  async flush() {
+    const logs = this._logger as any;
+    if (typeof logs.flush === "function") await logs.flush();
+  }
+
+  // Cierra recursos (conexiones, handles, etc.)
+  async dispose() {
+    const logs = this._logger as any;
+    if (typeof logs.dispose === "function") await logs.dispose();
+  }
+}
+```
+
+### Inicializador del Logger
+
+```ts
+// Path Ejemplo: src/infrastructure/logger/index.ts
+
+import { envs } from "../../../../config/plugins";
+// NOTA: envs es un archivo donde se leen variables de entorno .env
+import { LoggerBootstrap } from "./core/logger.bootstrap";
+import { parseLogLevel } from "./helper";
+// NOTA: parseLogLevel hace un match con los valores del objeto LogLevel de @jmlq/logger
+
+declare global {
+  var __LOGGER_BOOT__: Promise<LoggerBootstrap> | undefined;
+}
+
+async function init() {
+  return LoggerBootstrap.create({
+    minLevel: parseLogLevel(envs.logger.LOGGER_LEVEL),
+    pii: {
+      enabled: envs.logger.LOGGER_PII_ENABLED,
+      includeDefaults: envs.logger.LOGGER_PII_INCLUDE_DEFAULTS,
+      deep: true,
+      patterns: [
+        {
+          pattern: "\\b\\d{4}-\\d{4}-\\d{4}-\\d{4}\\b",
+          replaceWith: "****-****-****-****",
+        },
+        {
+          pattern: "[\\w.-]+@[\\w.-]+",
+          replaceWith: "***@***",
+        },
+      ],
+    },
+    adapters: {
+      // NOTA: Opcional, depende de las necesidades del cliente
+      fs: envs.logger.LOGGER_FS_PATH
+        ? {
+            basePath: envs.logger.LOGGER_FS_PATH,
+            fileNamePattern: "app-{yyyy}{MM}{dd}.log",
+            rotation: { by: "day" },
+            mkdir: true,
+            onRotate: (oldPath, newPath) => {
+              console.log(
+                `   [Rotate] Rotación completada: ${oldPath.absolutePath} → ${newPath.absolutePath}`
+              );
+            },
+            onError: (err) => {
+              console.error("   [Error Handler]", err.message);
+            },
+          }
+        : undefined,
+      mongo: envs.logger.LOGGER_MONGO_DB_URL
+        ? ({
+            dbName: envs.logger.LOGGER_MONGO_DB_NAME ?? "logs",
+            collectionName:
+              envs.logger.LOGGER_MONGO_COLLECTION_NAME ?? "app_logs",
+            ensureIndexes: true,
+            retentionDays: 7,
+            extraIndexes: [{ key: { level: 1 } }],
+            createIfMissing: true,
+          } as any)
+        : undefined,
+      pg: envs.logger.LOGGER_PG_CONNECTION_STRING
+        ? ({
+            schema: envs.logger.LOGGER_PG_SCHEMA ?? "public",
+            table: envs.logger.LOGGER_PG_TABLE_NAME ?? "logs",
+            createIfMissing: true,
+            enablePrune: true,
+          } as any)
+        : undefined,
+    },
+  });
+}
+
+// 1. Es una promesa singleton de LoggerBootstrap
+// 2. Usa el operador nullish-coalescing (??) para: Reutilizar globalThis.__LOGGER_BOOT__ si ya existe.
+//    En caso contrario crea y memoriza (= init()) la promesa si no existe aún.
+// 3. Garantiza una sola inicialización global del sistema de logging (adapters, datasources, PII, etc.)
+//    aunque el módulo se importe múltiples veces
+export const bootReady: Promise<LoggerBootstrap> =
+  globalThis.__LOGGER_BOOT__ ?? (globalThis.__LOGGER_BOOT__ = init());
+
+// 1. Es una promesa que resuelve directamente al logger
+// 2. Hace un map de la promesa anterior: bootReady.then(b => b.logger).
+export const loggerReady = bootReady.then((b) => b.logger);
+
+// 1. Espera a bootReady y llama boot.flush(), que a su vez pide al logger/datasources
+//    que vacíen buffers pendientes (útil antes de apagar el proceso o en tests).
+export async function flushLogs() {
+  const boot = await bootReady;
+  await boot.flush();
+}
+
+// 1. Espera a bootReady y llama boot.dispose(), que cierra recursos
+//    (conexiones a MongoDB/Postgres, file handles, etc.)
+export async function disposeLogs() {
+  const boot = await bootReady;
+  await boot.dispose();
+}
+```
+
+---
+
+## Configuración en Frameworks
+
+**NOTA**: Se sugiere realizarlo en la capa `presentation` de la API que implementa `@jmlq/logger` y/o sus plugins.
+
+### Express
+
+#### Crear middleware (opcional):
+
+Se puede realizar de la forma que el usuario considere conveniente
+
+```ts
+// Path Ejemplo: src/presentation/middlewares/attach-logger.middleware.ts
+
+import { ILogger } from "@jmlq/logger";
+import { randomUUID } from "crypto";
+import { Request, Response, NextFunction } from "express";
+
+/**
+ * Middleware factory que adjunta contexto de logging al request.
+ *
+ * Responsabilidades:
+ * 1. Inyectar un logger base accesible desde cualquier controller/middleware.
+ * 2. Garantizar un requestId único para trazabilidad y correlación de logs.
+ *
+ * No configura el logger ni emite logs:
+ * solo prepara el contexto por request.
+ */
+export function attachLogger(base: ILogger) {
+  /**
+   * Middleware de Express ejecutado en cada request HTTP.
+   */
+  return async (req: Request, _res: Response, next: NextFunction) => {
+    /**
+     * Se adjunta el logger al objeto Request para evitar:
+     * - imports globales
+     * - singletons
+     * - acoplamiento directo en controllers
+     */
+    req.logger = base;
+
+    /**
+     * Se asigna un identificador único por request.
+     *
+     * - Si el cliente ya envía "x-request-id" (ej. API Gateway, Load Balancer),
+     *   se reutiliza para mantener trazabilidad entre servicios.
+     * - Si no existe, se genera un UUID local.
+     */
+    req.requestId = (req.headers["x-request-id"] as string) ?? randomUUID();
+
+    /**
+     * Continúa el pipeline normal de Express.
+     */
+    next();
+  };
+}
+```
+
+#### Adjuntar middleware en el servidor
+
+```ts
+// Path Ejemplo: src/presentation/server.ts
+
+import { ILogger } from "@jmlq/logger";
+import express from "express";
+import { attachLogger } from "./middlewares";
+
+export function createServer(base: ILogger) {
+  const app = express();
+  app.use(express.json()); // <-- necesario para POST JSON
+  app.use(attachLogger(base));
+
+  app.get("/health", (_req, res) => res.json({ ok: true }));
+
+  return app;
+}
+```
+
+#### Iniciar servidor
+
+**NOTA**: Esto se realiza en la raíz de la API
+
+```ts
+// Path Ejemplo: src/app.ts
+
+import { envs } from "./config/plugins";
+import { disposeLogs, flushLogs, loggerReady } from "./infrastructure/logger";
+import { createServer } from "./presentation/server";
+
+async function bootstrap() {
+  const logger = await loggerReady;
+
+  const app = createServer(logger);
+  const server = app.listen(envs.PORT, envs.HOST, () => {
+    console.log(`🚀 Server running at http://${envs.HOST}:${envs.PORT}`);
+    logger.info("http.start", { host: envs.HOST, port: envs.PORT });
+  });
+
+  server.on("error", async (err: any) => {
+    logger.error("http.listen.error", {
+      message: err?.message,
+      stack: err?.stack,
+    });
+    await flushLogs().catch(() => {});
+    await disposeLogs().catch(() => {});
+    process.exit(1);
+  });
+
+  // 3) Señales de apagado limpio
+  const shutdown = async (reason: string, code = 0) => {
+    logger.info("app.shutdown.begin", { reason });
+    server.close(async () => {
+      try {
+        await flushLogs();
+      } catch {}
+      try {
+        await disposeLogs();
+      } catch {}
+      logger.info("app.shutdown.end", { code });
+      process.exit(code);
+    });
+  };
+
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+
+  // Fallos no controlados
+  process.on("unhandledRejection", async (err) => {
+    const e = err as any;
+    logger.error("unhandled.rejection", {
+      message: e?.message,
+      stack: e?.stack,
+    });
+    await shutdown("unhandledRejection", 1);
+  });
+
+  process.on("uncaughtException", async (err) => {
+    logger.error("uncaught.exception", {
+      message: err.message,
+      stack: err.stack,
+    });
+    await shutdown("uncaughtException", 1);
+  });
+}
+
+bootstrap().catch(async (err) => {
+  // Falla durante el bootstrap
+  const logger = await loggerReady.catch(() => null);
+  if (logger) {
+    logger.error("bootstrap.fatal", {
+      message: (err as Error)?.message,
+      stack: (err as Error)?.stack,
+    });
+    await flushLogs().catch(() => {});
+    await disposeLogs().catch(() => {});
+  } else {
+    // último recurso si el logger no llegó a inicializar
+    console.error("Fatal error (no logger):", err);
+  }
+  process.exit(1);
+});
+```
+
+---
+
+## 🎯 Características Principales
+
+### Niveles de Log
+
+- `TRACE` (10) - Información muy detallada
+- `DEBUG` (20) - Información de depuración
+- `INFO` (30) - Información general
+- `WARN` (40) - Advertencias
+- `ERROR` (50) - Errores
+- `FATAL` (60) - Errores críticos
+
+### Enmascarado PII Automático
+
+El logger detecta y enmascara automáticamente datos sensibles utilizando patrones personalizados:
+
+```js
+patterns: [
+  // Tarjetas de crédito
+  {
+    pattern: "\\b\\d{4}[-\\s]?\\d{4}[-\\s]?\\d{4}[-\\s]?\\d{4}\\b",
+    replaceWith: "****-****-****-****",
+  },
+  // Números de cuenta bancaria
+  {
+    pattern: "\\b\\d{10,20}\\b",
+    replaceWith: "****ACCOUNT****",
+  },
+  // Tokens JWT
+  {
+    pattern: "eyJ[A-Za-z0-9-_=]+\\.[A-Za-z0-9-_=]+\\.?[A-Za-z0-9-_.+/=]*",
+    replaceWith: "****JWT****",
+  },
+],
+```
+
+Por ejemplo, si se tiene la siguiente información:
+
+```js
+[
+  {
+    id: "1",
+    name: "John Doe",
+    email: "john.doe@example.com",
+    card: "1234-5678-9012-3456",
+  },
+  {
+    id: "2",
+    name: "Jane Doe",
+    email: "jane.doe@example.com",
+    card: "6258-3842-9524-3251",
+  },
+];
+```
+
+Los logs registrarán lo siguiente:
+
+> - **Archivo .log** (`@jmlq/logger-plugin-fs`)
+
+```js
+{
+  "level": 30,
+  "message": "Users listed successfully",
+  "meta": {
+    "count": 2,
+    "result": [
+      {
+        "id": "1",
+        "name": "John Doe",
+        "email": "***@***",
+        "card": "****-****-****-****"
+      },
+      {
+        "id": "2",
+        "name": "Jane Doe",
+        "email": "***@***",
+        "card": "****-****-****-****"
+      }
+    ]
+  },
+  "timestamp": 1765400661565,
+  "_id": "6939e0556925736129e1008d"
+}
+```
+
+> - **MongoDB** (`@jmlq/logger-plugin-mongo`)
+
+![MongoDB log](assets/mongo-log.png)
+
+> - **PostgreSQL** (`@jmlq/logger-plugin-postgresql`)
+
+![PostgreSQL log](assets/pg-log.png)
+
+### Filtros y Consultas
+
+#### 1. Obtener todos los logs de nivel WARN o superior (retorna WARN, ERROR y FATAL)
+
+```ts
+const errors = await _req.logger?.getLogs({
+  levelMin: parseLogLevel("WARN"),
+});
+```
+
+Resultado:
+
+```ini
+[2025-12-10T21:19:58.804Z] [50] app.error {"name":"AppError","code":"INTERNAL","message":"Unhandled exception","retryable":false,"meta":null,"cause":{"cause":{}},"stack":"AppError: Unhandled exception\n    at AppError.internal (D:\\Fuentes\\Core\\ml-dev-rest-api\\dist\\shared\\errors\\app-error.js:61:16)\n    at D:\\Fuentes\\Core\\ml-dev-rest-api\\dist\\presentation\\middlewares\\http\\error.middleware.js:36:40\n    at Layer.handleError (D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\lib\\layer.js:116:17)\n
+   at trimPrefix (D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\index.js:340:13)\n    at D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\index.js:297:9\n    at processParams (D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\index.js:582:12)\n    at Immediate.next (D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\index.js:291:5)\n    at Immediate._onImmediate (D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\index.js:688:15)\n    at process.processImmediate (node:internal/timers:485:21)"}
+```
+
+**NOTA**: `parseLogLevel` es un helper para convertir un `string` a `LogLevel`.
+
+#### 2. Filtrar por rango de fechas
+
+```ts
+const yesterday = Date.now() - 24 * 60 * 60 * 1000;
+const recentLogs = await _req.logger?.getLogs({
+  since: yesterday,
+  until: Date.now(),
+});
+```
+
+Resultado:
+
+```ini
+[2025-12-10T22:21:58.500Z] [30] app.shutdown.begin {"reason":"SIGINT"}
+[2025-12-10T21:12:59.216Z] [50] app.error {"name":"AppError","code":"INTERNAL","message":"Unhandled exception","retryable":false,"meta":null,"cause":{"cause":{}},"stack":"AppError: Unhandled exception\n    at AppError.internal (D:\\Fuentes\\Core\\ml-dev-rest-api\\dist\\shared\\errors\\app-error.js:61:16)"}
+[2025-12-10T21:04:21.565Z] [30] Users listed successfully {"count":2,"result":[{"id":"1","name":"John Doe","email":"***@***","card":"****-****-****-****"},{"id":"2","name":"Jane Doe","email":"***@***","card":"****-****-****-****"}]}
+[2025-12-10T21:03:32.910Z] [30] http.start {"host":"127.0.0.1","port":3000}
+```
+
+#### 3. Búsqueda por texto (en el campo mensaje del log)
+
+```ts
+const userLogs = await _req.logger?.getLogs({
+  query: "Users",
+});
+```
+
+Resultado:
+
+```ini
+[2025-12-10T22:58:09.874Z] [30] Users listed successfully {"count":2,"result":[{"id":"1","card":"****-****-****-****","name":"John Doe","email":"***@***"},{"id":"2","card":"****-****-****-****","name":"Jane Doe","email":"***@***"}]}
+[2025-12-10T22:57:28.483Z] [30] Users listed successfully {"count":2,"result":[{"id":"1","name":"John Doe","email":"***@***","card":"****-****-****-****"},{"id":"2","name":"Jane Doe","email":"***@***","card":"****-****-****-****"}]}
+```
+
+#### 4. Combinación de filtros
+
+```ts
+const logs = await _req.logger?.getLogs({
+  levelMin: parseLogLevel("INFO"),
+  since: Date.now() - 2 * 60 * 60 * 1000, // Últimas 2 horas
+  query: "successfully",
+});
+```
+
+Resultado:
+
+```ini
+[2025-12-10T23:05:31.791Z] [30] Users listed successfully {"count":2,"result":[{"id":"1","name":"John Doe","email":"***@***","card":"****-****-****-****"},{"id":"2","name":"Jane Doe","email":"***@***","card":"****-****-****-****"}]}
+[2025-12-10T23:05:31.791Z] [30] Users listed successfully {"count":2,"result":[{"id":"1","card":"****-****-****-****","name":"John Doe","email":"***@***"},{"id":"2","card":"****-****-****-****","name":"Jane Doe","email":"***@***"}]}
+[2025-12-10T22:58:09.874Z] [30] Users listed successfully {"count":2,"result":[{"id":"1","name":"John Doe","email":"***@***","card":"****-****-****-****"},{"id":"2","name":"Jane Doe","email":"***@***","card":"****-****-****-****"}]}
+```
+
+## 📄 Más Información
+
+- **[Arquitectura Detallada](./architecture.md)** - Documentación técnica completa
+
+## 📝 Licencia
+
+MIT © Mauricio Lahuasi