@rempays/shared-core 1.0.2-beta.10 → 1.0.2-beta.12

package/dist/dynamodb/dynamodb.client.d.ts

@@ -1,7 +1,4 @@
-/**
- * Cliente genérico de DynamoDB
- * Wrapper type-safe sobre AWS SDK
- */
+import type { PaginatedResult } from './modules/shared-types.js';
 export interface DynamoDBConfig {
     region?: string;
     endpoint?: string;
@@ -25,6 +22,7 @@ export interface QueryOptions {
     expressionAttributeValues?: Record<string, any>;
     limit?: number;
     scanIndexForward?: boolean;
+    lastEvaluatedKey?: Record<string, any>;
 }
 export declare class DynamoDBClientWrapper {
     private client;
@@ -46,9 +44,33 @@ export declare class DynamoDBClientWrapper {
      */
     delete(tableName: string, key: Record<string, any>): Promise<void>;
     /**
-     * Query con índice o clave primaria
+     * Query con índice o clave primaria (con paginación)
      */
-    query<T extends Record<string, any>>(tableName: string, options: QueryOptions): Promise<T[]>;
+    query<T extends Record<string, any>>(tableName: string, options: QueryOptions): Promise<PaginatedResult<T>>;
+    /**
+     * Query simple por PK (Partition Key)
+     */
+    queryByPK<T extends Record<string, any>>(tableName: string, pkName: string, pkValue: any, options?: {
+        limit?: number;
+        scanIndexForward?: boolean;
+        lastEvaluatedKey?: Record<string, any>;
+    }): Promise<PaginatedResult<T>>;
+    /**
+     * Query por PK y SK (Sort Key) con operador
+     */
+    queryByPKAndSK<T extends Record<string, any>>(tableName: string, pkName: string, pkValue: any, skName: string, skOperator: '=' | '<' | '<=' | '>' | '>=' | 'BETWEEN' | 'begins_with', skValue: any, skValue2?: any, // Para BETWEEN
+    options?: {
+        limit?: number;
+        scanIndexForward?: boolean;
+        lastEvaluatedKey?: Record<string, any>;
+        indexName?: string;
+    }): Promise<PaginatedResult<T>>;
+    /**
+     * Query todos los items por PK (sin límite, con paginación automática)
+     */
+    queryAllByPK<T extends Record<string, any>>(tableName: string, pkName: string, pkValue: any, options?: {
+        scanIndexForward?: boolean;
+    }): Promise<T[]>;
     /**
      * Scan completo de la tabla (usar con cuidado)
      */
@@ -64,4 +86,32 @@ export declare class DynamoDBClientWrapper {
      * Batch get (obtener múltiples items)
      */
     batchGet<T extends Record<string, any>>(tableName: string, keys: Array<Record<string, any>>): Promise<T[]>;
+    /**
+     * Verifica si un item existe
+     */
+    exists(tableName: string, key: Record<string, any>): Promise<boolean>;
+    /**
+     * Incrementa un atributo numérico
+     */
+    increment<T extends Record<string, any>>(tableName: string, key: Record<string, any>, attributeName: string, incrementBy?: number): Promise<T>;
+    /**
+     * Decrementa un atributo numérico
+     */
+    decrement<T extends Record<string, any>>(tableName: string, key: Record<string, any>, attributeName: string, decrementBy?: number): Promise<T>;
+    /**
+     * Agrega items a una lista (array)
+     */
+    appendToList<T extends Record<string, any>>(tableName: string, key: Record<string, any>, attributeName: string, values: any[]): Promise<T>;
+    /**
+     * Agrega items a un Set
+     */
+    addToSet<T extends Record<string, any>>(tableName: string, key: Record<string, any>, attributeName: string, values: any[]): Promise<T>;
+    /**
+     * Elimina items de un Set
+     */
+    removeFromSet<T extends Record<string, any>>(tableName: string, key: Record<string, any>, attributeName: string, values: any[]): Promise<T>;
+    /**
+     * Elimina un atributo
+     */
+    removeAttribute<T extends Record<string, any>>(tableName: string, key: Record<string, any>, attributeName: string): Promise<T>;
 }

package/dist/dynamodb/dynamodb.client.js

@@ -1,8 +1,4 @@
 "use strict";
-/**
- * Cliente genérico de DynamoDB
- * Wrapper type-safe sobre AWS SDK
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DynamoDBClientWrapper = void 0;
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
@@ -80,7 +76,7 @@ class DynamoDBClientWrapper {
         await this.client.send(command);
     }
     /**
-     * Query con índice o clave primaria
+     * Query con índice o clave primaria (con paginación)
      */
     async query(tableName, options) {
         const command = new client_dynamodb_1.QueryCommand({
@@ -100,12 +96,87 @@ class DynamoDBClientWrapper {
             ...(options.scanIndexForward !== undefined && {
                 ScanIndexForward: options.scanIndexForward,
             }),
+            ...(options.lastEvaluatedKey && {
+                ExclusiveStartKey: (0, util_dynamodb_1.marshall)(options.lastEvaluatedKey),
+            }),
         });
         const response = await this.client.send(command);
-        if (!response.Items || response.Items.length === 0) {
-            return [];
+        const items = response.Items?.map((item) => (0, util_dynamodb_1.unmarshall)(item)) || [];
+        const lastEvaluatedKey = response.LastEvaluatedKey
+            ? (0, util_dynamodb_1.unmarshall)(response.LastEvaluatedKey)
+            : undefined;
+        return {
+            items,
+            lastEvaluatedKey,
+            hasMore: !!lastEvaluatedKey,
+            count: items.length,
+        };
+    }
+    /**
+     * Query simple por PK (Partition Key)
+     */
+    async queryByPK(tableName, pkName, pkValue, options) {
+        return this.query(tableName, {
+            keyConditionExpression: `#pk = :pk`,
+            expressionAttributeNames: { '#pk': pkName },
+            expressionAttributeValues: { ':pk': pkValue },
+            ...options,
+        });
+    }
+    /**
+     * Query por PK y SK (Sort Key) con operador
+     */
+    async queryByPKAndSK(tableName, pkName, pkValue, skName, skOperator, skValue, skValue2, // Para BETWEEN
+    options) {
+        let keyConditionExpression;
+        let expressionAttributeValues;
+        if (skOperator === 'BETWEEN' && skValue2 !== undefined) {
+            keyConditionExpression = `#pk = :pk AND #sk BETWEEN :sk1 AND :sk2`;
+            expressionAttributeValues = {
+                ':pk': pkValue,
+                ':sk1': skValue,
+                ':sk2': skValue2,
+            };
         }
-        return response.Items.map((item) => (0, util_dynamodb_1.unmarshall)(item));
+        else if (skOperator === 'begins_with') {
+            keyConditionExpression = `#pk = :pk AND begins_with(#sk, :sk)`;
+            expressionAttributeValues = {
+                ':pk': pkValue,
+                ':sk': skValue,
+            };
+        }
+        else {
+            keyConditionExpression = `#pk = :pk AND #sk ${skOperator} :sk`;
+            expressionAttributeValues = {
+                ':pk': pkValue,
+                ':sk': skValue,
+            };
+        }
+        return this.query(tableName, {
+            keyConditionExpression,
+            expressionAttributeNames: {
+                '#pk': pkName,
+                '#sk': skName,
+            },
+            expressionAttributeValues,
+            ...options,
+        });
+    }
+    /**
+     * Query todos los items por PK (sin límite, con paginación automática)
+     */
+    async queryAllByPK(tableName, pkName, pkValue, options) {
+        const allItems = [];
+        let lastEvaluatedKey;
+        do {
+            const result = await this.queryByPK(tableName, pkName, pkValue, {
+                ...options,
+                lastEvaluatedKey,
+            });
+            allItems.push(...result.items);
+            lastEvaluatedKey = result.lastEvaluatedKey;
+        } while (lastEvaluatedKey);
+        return allItems;
     }
     /**
      * Scan completo de la tabla (usar con cuidado)
@@ -166,5 +237,87 @@ class DynamoDBClientWrapper {
         }
         return response.Responses[tableName].map((item) => (0, util_dynamodb_1.unmarshall)(item));
     }
+    /**
+     * Verifica si un item existe
+     */
+    async exists(tableName, key) {
+        const item = await this.get(tableName, key);
+        return item !== null;
+    }
+    /**
+     * Incrementa un atributo numérico
+     */
+    async increment(tableName, key, attributeName, incrementBy = 1) {
+        return this.update(tableName, key, {
+            updateExpression: `SET #attr = if_not_exists(#attr, :zero) + :inc`,
+            expressionAttributeNames: {
+                '#attr': attributeName,
+            },
+            expressionAttributeValues: {
+                ':zero': 0,
+                ':inc': incrementBy,
+            },
+        });
+    }
+    /**
+     * Decrementa un atributo numérico
+     */
+    async decrement(tableName, key, attributeName, decrementBy = 1) {
+        return this.increment(tableName, key, attributeName, -decrementBy);
+    }
+    /**
+     * Agrega items a una lista (array)
+     */
+    async appendToList(tableName, key, attributeName, values) {
+        return this.update(tableName, key, {
+            updateExpression: `SET #attr = list_append(if_not_exists(#attr, :empty), :vals)`,
+            expressionAttributeNames: {
+                '#attr': attributeName,
+            },
+            expressionAttributeValues: {
+                ':empty': [],
+                ':vals': values,
+            },
+        });
+    }
+    /**
+     * Agrega items a un Set
+     */
+    async addToSet(tableName, key, attributeName, values) {
+        return this.update(tableName, key, {
+            updateExpression: `ADD #attr :vals`,
+            expressionAttributeNames: {
+                '#attr': attributeName,
+            },
+            expressionAttributeValues: {
+                ':vals': new Set(values),
+            },
+        });
+    }
+    /**
+     * Elimina items de un Set
+     */
+    async removeFromSet(tableName, key, attributeName, values) {
+        return this.update(tableName, key, {
+            updateExpression: `DELETE #attr :vals`,
+            expressionAttributeNames: {
+                '#attr': attributeName,
+            },
+            expressionAttributeValues: {
+                ':vals': new Set(values),
+            },
+        });
+    }
+    /**
+     * Elimina un atributo
+     */
+    async removeAttribute(tableName, key, attributeName) {
+        return this.update(tableName, key, {
+            updateExpression: `REMOVE #attr`,
+            expressionAttributeNames: {
+                '#attr': attributeName,
+            },
+        });
+    }
 }
 exports.DynamoDBClientWrapper = DynamoDBClientWrapper;

package/dist/dynamodb/modules/chat/chat.service.d.ts

@@ -46,12 +46,9 @@ export declare class ChatService {
     listChatsByBusiness(businessId: string, status: string, params?: PaginationParams): Promise<PaginatedResult<Chat>>;
     /**
      * Lista todos los chats de un business (todos los status)
+     * Nota: Hace múltiples queries, una por cada status común
      */
     listAllChatsByBusiness(businessId: string, params?: PaginationParams): Promise<PaginatedResult<Chat>>;
-    /**
-     * Incrementa el contador de mensajes no leídos
-     */
-    incrementUnreadCount(chatId: string): Promise<void>;
     /**
      * Marca todos los mensajes como leídos
      */

package/dist/dynamodb/modules/chat/chat.service.js

@@ -242,48 +242,33 @@ class ChatService {
     }
     /**
      * Lista todos los chats de un business (todos los status)
+     * Nota: Hace múltiples queries, una por cada status común
      */
     async listAllChatsByBusiness(businessId, params = {}) {
-        const { limit = 20, lastEvaluatedKey } = params;
-        const result = await this.client.send(new client_dynamodb_1.QueryCommand({
-            TableName: this.tableName,
-            IndexName: 'GSI1',
-            KeyConditionExpression: 'begins_with(GSI1PK, :prefix)',
-            ExpressionAttributeValues: (0, util_dynamodb_1.marshall)({
-                ':prefix': `BUSINESS#${businessId}#`,
-            }),
-            ScanIndexForward: false,
-            Limit: limit,
-            ExclusiveStartKey: lastEvaluatedKey ? (0, util_dynamodb_1.marshall)(lastEvaluatedKey) : undefined,
-        }));
-        const items = result.Items?.map((item) => {
-            const data = (0, util_dynamodb_1.unmarshall)(item);
-            const { PK, SK, GSI1PK, GSI1SK, ...chat } = data;
-            return chat;
-        }) || [];
+        const { limit = 20 } = params;
+        const statuses = ['active', 'closed', 'pending', 'archived'];
+        const allChats = [];
+        // Query para cada status
+        for (const status of statuses) {
+            const result = await this.listChatsByBusiness(businessId, status, {
+                limit: Math.ceil(limit / statuses.length),
+            });
+            allChats.push(...result.items);
+            // Si ya tenemos suficientes, parar
+            if (allChats.length >= limit) {
+                break;
+            }
+        }
+        // Ordenar por lastMessageTimestamp descendente
+        allChats.sort((a, b) => b.lastMessageTimestamp - a.lastMessageTimestamp);
+        // Limitar resultados
+        const items = allChats.slice(0, limit);
         return {
             items,
-            lastEvaluatedKey: result.LastEvaluatedKey ? (0, util_dynamodb_1.unmarshall)(result.LastEvaluatedKey) : undefined,
-            hasMore: !!result.LastEvaluatedKey,
+            lastEvaluatedKey: undefined,
+            hasMore: allChats.length > limit,
         };
     }
-    /**
-     * Incrementa el contador de mensajes no leídos
-     */
-    async incrementUnreadCount(chatId) {
-        await this.client.send(new client_dynamodb_1.UpdateItemCommand({
-            TableName: this.tableName,
-            Key: (0, util_dynamodb_1.marshall)({
-                PK: `CHAT#${chatId}`,
-                SK: 'METADATA',
-            }),
-            UpdateExpression: 'SET unreadCount = if_not_exists(unreadCount, :zero) + :inc',
-            ExpressionAttributeValues: (0, util_dynamodb_1.marshall)({
-                ':inc': 1,
-                ':zero': 0,
-            }),
-        }));
-    }
     /**
      * Marca todos los mensajes como leídos
      */

package/dist/dynamodb/modules/shared-types.d.ts

@@ -6,4 +6,5 @@ export interface PaginatedResult<T> {
     items: T[];
     lastEvaluatedKey?: Record<string, any>;
     hasMore: boolean;
+    count?: number;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rempays/shared-core",
-    "version": "1.0.2-beta.10",
+    "version": "1.0.2-beta.12",
     "description": "Core utilities layer for RemPays platform with AWS services integration (Cognito, S3, Secrets Manager, Textract, Facebook API, DynamoDB)",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -38,7 +38,8 @@
         "build": "tsc",
         "build:watch": "tsc --watch",
         "prepublishOnly": "npm run build",
-        "dev": "tsc --watch"
+        "dev": "tsc --watch",
+        "test:chat": "tsx examples/test-chat-service.ts"
     },
     "dependencies": {
         "@aws-sdk/client-cognito-identity-provider": "^3.454.0",
@@ -50,6 +51,8 @@
     },
     "devDependencies": {
         "@types/node": "^20.11.0",
+        "dotenv": "^17.3.1",
+        "tsx": "^4.7.0",
         "typescript": "^5.3.0"
     },
     "files": [