minimonolith 0.26.20 → 0.27.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "minimonolith",
   "type": "module",
-  "version": "0.26.20",
+  "version": "0.27.0",
   "main": "index.js",
   "license": "MIT",
   "scripts": {
@@ -17,12 +17,16 @@
     "sequelize": "^6.30.0"
   },
   "devDependencies": {
+    "@aws-sdk/client-dynamodb": "^3.1048.0",
     "@aws-sdk/client-s3": "^3.304.0",
+    "@aws-sdk/lib-dynamodb": "^3.1048.0",
     "@aws-sdk/s3-request-presigner": "^3.304.0",
     "@jest/globals": "^30.2.0",
     "cross-env": "^7.0.3",
     "cross-fetch": "^3.1.5",
     "dotenv": "^16.0.3",
+    "dynalite": "^4.0.0",
+    "electrodb": "^3.7.5",
     "jest": "^29.5.0",
     "mysql2": "^3.2.0",
     "nodemon": "^2.0.22",

package/src/api/get/index.js

@@ -6,12 +6,15 @@ import MIDDLEWARE_MODULE from '../../middleware/index.js';
 
 import postModule from '../postModule/index.js';
 import getSyncedHandler from '../getSyncedHandler/index.js';
+import getElectroHandler from '../getElectroHandler/index.js';
 
 const API = getLambdaAPI();
 API.postCORSMiddleware = MIDDLEWARE_MODULE.postCors;
 API.postModule = postModule;
 API.postDatabaseModule = DATABASE_MODULE.post;
+API.postDynamoDBModule = DATABASE_MODULE.postDynamoDB;
 API.postErrorMiddleware = MIDDLEWARE_MODULE.postError;
 API.getSyncedHandler = getSyncedHandler;
+API.getElectroHandler = getElectroHandler;
 
 export default () => API;

package/src/api/getElectroHandler/index.js

@@ -0,0 +1,30 @@
+import MODEL_MODULE from '../../model/index.js';
+import LOG_MODULE from '../../log/index.js';
+
+import getAPI from '../get/index.js';
+
+const META_MODULE='API', META_ENDPOINT='GET_ELECTRO_HANDLER',
+      META_ROUTE=META_MODULE+'_'+META_ENDPOINT;
+
+export default async () => {
+   // 1. Configurar middlewares (se mantiene igual)
+   getAPI().postErrorMiddleware();
+
+   // 2. Cargar Entidades de ElectroDB (en lugar de sincronizar ORM)
+   if (getAPI().DYNAMO_CLIENT) {
+       // Asumiendo que el archivo que creamos antes en model se exporta como getElectro
+       await MODEL_MODULE.getElectro(); 
+   }
+
+   LOG_MODULE.postINFO(`API (DynamoDB Mode) listening...`);
+
+   // 3. Retornar el handler para AWS Lambda (se mantiene igual)
+   return async (event, context) => {
+     LOG_MODULE.postINFO('ENDPOINT request:', {
+       path: event.requestContext?.http?.path,
+       method: event.requestContext?.http?.method,
+     });
+
+     return await getAPI().run(event, context);
+   };
+};

package/src/database/index.js

@@ -1,4 +1,5 @@
 import post from './post/index.js';
 import postConnection from './postConnection/index.js';
+import postDynamoDB from './postDynamoDB/index.js';
 
-export default { post, postConnection };
+export default { post, postConnection, postDynamoDB };

package/src/database/post/index.js

@@ -19,7 +19,7 @@ export default async ({ DB_DIALECT, DB_HOST,
     const DB_VARS = Object.fromEntries(
         Object.entries({
             DB_DIALECT, DB_HOST, DB_PORT, DB_DB,
-            DB_USER, DB_PASS, DB_STORAGE })
+            DB_USER, DB_PASS, DB_STORAGE, DB_SSL })
         .filter(([key, val]) => val != null)
     );
 

package/src/database/postDynamoDB/index.js

@@ -0,0 +1,83 @@
+import { DynamoDBClient, CreateTableCommand, ListTablesCommand } from '@aws-sdk/client-dynamodb';
+import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
+
+import API_MODULE  from '../../api/index.js';
+import LOG_MODULE from '../../log/index.js';
+import ERROR_MODULE from '../../error/index.js';
+
+const META_MODULE='DATABASE', META_METHOD='POST_DYNAMODB',
+      META_ROUTE=META_MODULE+'_'+META_METHOD;
+
+export default async ({
+    AWS_REGION, DYNAMO_TABLE, DYNALITE_PORT
+}) => {
+  try {
+    LOG_MODULE.postDEBUG(`Initializing DynamoDB connection...`);
+
+    const clientConfig = {
+      region: AWS_REGION || 'us-east-1',
+    };
+
+    const localPort = parseInt(DYNALITE_PORT, 10);
+
+
+    if (!isNaN(localPort)) {
+
+      LOG_MODULE.postINFO(`Starting Dynalite (In-Memory DynamoDB) on port ${localPort}, table ${DYNAMO_TABLE}...`);
+
+      // Importación dinámica: Así evitamos que Lambda intente cargar 
+      // dynalite en producción donde no estará instalado.
+      const dynalite = (await import('dynalite')).default;
+      const dynaliteServer = dynalite({ createTableMs: 0 });
+
+      await new Promise((resolve, reject) => {
+        dynaliteServer.listen(localPort, (err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+
+      // Sobrescribimos la configuración para que el SDK apunte a local
+      clientConfig.endpoint = `http://localhost:${localPort}`;
+      clientConfig.credentials = { accessKeyId: 'local', secretAccessKey: 'local' };
+
+      // Guardamos la instancia por si queremos apagarla después (útil en testing)
+      API_MODULE.get().DYNALITE_SERVER = dynaliteServer;
+    }
+
+    const client = new DynamoDBClient(clientConfig);
+    const marshallOptions = { removeUndefinedValues: true };
+
+    // Guardamos el DocumentClient (equivalente al "ORM" para ElectroDB)
+    API_MODULE.get().DYNAMO_CLIENT = DynamoDBDocumentClient.from(client, { marshallOptions });
+
+    // Opcional: Guardamos el nombre de la tabla principal si usas Single Table Design
+    if (DYNAMO_TABLE) {
+        API_MODULE.get().DYNAMO_TABLE = DYNAMO_TABLE;
+    }
+
+    if (!isNaN(localPort) && DYNAMO_TABLE) {
+       LOG_MODULE.postINFO(`Auto-syncing local table: ${DYNAMO_TABLE}...`);
+       await client.send(new CreateTableCommand({
+           TableName: DYNAMO_TABLE,
+           AttributeDefinitions: [
+               { AttributeName: 'pk', AttributeType: 'S' },
+               { AttributeName: 'sk', AttributeType: 'S' }
+           ],
+           KeySchema: [
+               { AttributeName: 'pk', KeyType: 'HASH' },
+               { AttributeName: 'sk', KeyType: 'RANGE' }
+           ],
+           BillingMode: 'PAY_PER_REQUEST'
+       }));
+
+       const existingTables = await client.send(new ListTablesCommand({}));
+       LOG_MODULE.postINFO(`Tablas reales en Dynalite:`, existingTables.TableNames);
+    }
+
+    LOG_MODULE.postINFO(`DynamoDB Document Client initialized successfully`);
+
+  } catch (META_METHOD_ERROR) {
+    ERROR_MODULE.postCompiletime({ META_ROUTE, META_METHOD_ERROR });
+  }
+}

package/src/middleware/postCors/index.js

@@ -22,9 +22,7 @@ export default () =>  {
 
   API_MODULE.get().options('/*', (req, res) => {
     const origin = req.headers.origin ? req.headers.origin : '*';
-    console.log('headers pre', res._headers);
     for (let k in CORS_HEADERS({ origin })) { res.header(k, CORS_HEADERS({ origin })[k]); }
-    console.log('headers post', res._headers);
     res.status(200).send({})
   });
 };

package/src/model/getElectro/index.js

@@ -0,0 +1,27 @@
+import API_MODULE from '../../api/index.js';
+import LOG_MODULE from '../../log/index.js';
+
+const META_MODULE='MODEL', META_METHOD='GET_ELECTRO_HANDLER',
+      META_ROUTE=META_MODULE+'_'+META_METHOD;
+const CYAN = '\x1b[36m', YELLOW = '\x1b[33m', END = '\x1b[0m';
+
+export default async () => {
+   // 1. Cargar Entidades/Servicios de ElectroDB
+   for (const MODULE_NAME of Object.keys(API_MODULE.get().SCHEMAS)) {
+      
+      const tableName = API_MODULE.get().DYNAMO_TABLE;
+      LOG_MODULE.postINFO(`ElectroDB Entity being loaded:`, `${CYAN}${MODULE_NAME}${END}`, `for table: ${tableName}`);
+
+      // Pasamos el DYNAMO_CLIENT y la configuración a la función del esquema
+      API_MODULE.get().MODELS[MODULE_NAME] = 
+            API_MODULE.get().SCHEMAS[MODULE_NAME]({
+                client: API_MODULE.get().DYNAMO_CLIENT,
+                table: tableName
+            });
+   }
+
+   LOG_MODULE.postINFO('DynamoDB Entities loaded. Skipping sync/associate phases.');
+
+   // Asumo que aquí devuelves el handler real de tu framework como lo haces en el getSynced original
+   // return API_MODULE.get().SERVER.getHandler(); (o lo que aplique a tu código base)
+};

package/src/model/index.js

@@ -1,4 +1,5 @@
 import getSynced from './getSynced/index.js';
+import getElectro from './getElectro/index.js';
 import post from './post/index.js';
 
-export default { getSynced, post };
+export default { getSynced, post, getElectro };