@rempays/shared-core 1.0.2-beta.1 → 1.0.2-beta.11

package/dist/cognito/index.js

@@ -1,2 +1,20 @@
-export { CognitoService } from './cognito.service';
-export * from './types';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CognitoService = void 0;
+var cognito_service_1 = require("./cognito.service");
+Object.defineProperty(exports, "CognitoService", { enumerable: true, get: function () { return cognito_service_1.CognitoService; } });
+__exportStar(require("./types"), exports);

package/dist/cognito/types.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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,12 +1,11 @@
-/**
- * Cliente genérico de DynamoDB
- * Wrapper type-safe sobre AWS SDK
- */
-import { DynamoDBClient, PutItemCommand, GetItemCommand, UpdateItemCommand, DeleteItemCommand, QueryCommand, ScanCommand, BatchWriteItemCommand, BatchGetItemCommand, } from '@aws-sdk/client-dynamodb';
-import { marshall, unmarshall } from '@aws-sdk/util-dynamodb';
-export class DynamoDBClientWrapper {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoDBClientWrapper = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+class DynamoDBClientWrapper {
     constructor(config = {}) {
-        this.client = new DynamoDBClient({
+        this.client = new client_dynamodb_1.DynamoDBClient({
             region: config.region || process.env.AWS_REGION || 'us-east-1',
             ...(config.endpoint && { endpoint: config.endpoint }),
         });
@@ -15,9 +14,9 @@ export class DynamoDBClientWrapper {
      * Inserta o actualiza un item
      */
     async put(tableName, item, options) {
-        const command = new PutItemCommand({
+        const command = new client_dynamodb_1.PutItemCommand({
             TableName: tableName,
-            Item: marshall(item, { removeUndefinedValues: true }),
+            Item: (0, util_dynamodb_1.marshall)(item, { removeUndefinedValues: true }),
             ...(options?.conditionExpression && {
                 ConditionExpression: options.conditionExpression,
             }),
@@ -25,7 +24,7 @@ export class DynamoDBClientWrapper {
                 ExpressionAttributeNames: options.expressionAttributeNames,
             }),
             ...(options?.expressionAttributeValues && {
-                ExpressionAttributeValues: marshall(options.expressionAttributeValues),
+                ExpressionAttributeValues: (0, util_dynamodb_1.marshall)(options.expressionAttributeValues),
             }),
         });
         await this.client.send(command);
@@ -34,23 +33,23 @@ export class DynamoDBClientWrapper {
      * Obtiene un item por su clave primaria
      */
     async get(tableName, key) {
-        const command = new GetItemCommand({
+        const command = new client_dynamodb_1.GetItemCommand({
             TableName: tableName,
-            Key: marshall(key),
+            Key: (0, util_dynamodb_1.marshall)(key),
         });
         const response = await this.client.send(command);
         if (!response.Item) {
             return null;
         }
-        return unmarshall(response.Item);
+        return (0, util_dynamodb_1.unmarshall)(response.Item);
     }
     /**
      * Actualiza un item
      */
     async update(tableName, key, options) {
-        const command = new UpdateItemCommand({
+        const command = new client_dynamodb_1.UpdateItemCommand({
             TableName: tableName,
-            Key: marshall(key),
+            Key: (0, util_dynamodb_1.marshall)(key),
             UpdateExpression: options.updateExpression,
             ...(options.conditionExpression && {
                 ConditionExpression: options.conditionExpression,
@@ -59,28 +58,28 @@ export class DynamoDBClientWrapper {
                 ExpressionAttributeNames: options.expressionAttributeNames,
             }),
             ...(options.expressionAttributeValues && {
-                ExpressionAttributeValues: marshall(options.expressionAttributeValues),
+                ExpressionAttributeValues: (0, util_dynamodb_1.marshall)(options.expressionAttributeValues),
             }),
             ReturnValues: 'ALL_NEW',
         });
         const response = await this.client.send(command);
-        return unmarshall(response.Attributes);
+        return (0, util_dynamodb_1.unmarshall)(response.Attributes);
     }
     /**
      * Elimina un item
      */
     async delete(tableName, key) {
-        const command = new DeleteItemCommand({
+        const command = new client_dynamodb_1.DeleteItemCommand({
             TableName: tableName,
-            Key: marshall(key),
+            Key: (0, util_dynamodb_1.marshall)(key),
         });
         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 QueryCommand({
+        const command = new client_dynamodb_1.QueryCommand({
             TableName: tableName,
             ...(options.indexName && { IndexName: options.indexName }),
             KeyConditionExpression: options.keyConditionExpression,
@@ -91,24 +90,99 @@ export class DynamoDBClientWrapper {
                 ExpressionAttributeNames: options.expressionAttributeNames,
             }),
             ...(options.expressionAttributeValues && {
-                ExpressionAttributeValues: marshall(options.expressionAttributeValues),
+                ExpressionAttributeValues: (0, util_dynamodb_1.marshall)(options.expressionAttributeValues),
             }),
             ...(options.limit && { Limit: options.limit }),
             ...(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) => 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)
      */
     async scan(tableName, limit) {
-        const command = new ScanCommand({
+        const command = new client_dynamodb_1.ScanCommand({
             TableName: tableName,
             ...(limit && { Limit: limit }),
         });
@@ -116,7 +190,7 @@ export class DynamoDBClientWrapper {
         if (!response.Items || response.Items.length === 0) {
             return [];
         }
-        return response.Items.map((item) => unmarshall(item));
+        return response.Items.map((item) => (0, util_dynamodb_1.unmarshall)(item));
     }
     /**
      * Batch write (put o delete múltiples items)
@@ -126,20 +200,20 @@ export class DynamoDBClientWrapper {
             if (item.put) {
                 return {
                     PutRequest: {
-                        Item: marshall(item.put, { removeUndefinedValues: true }),
+                        Item: (0, util_dynamodb_1.marshall)(item.put, { removeUndefinedValues: true }),
                     },
                 };
             }
             else if (item.delete) {
                 return {
                     DeleteRequest: {
-                        Key: marshall(item.delete),
+                        Key: (0, util_dynamodb_1.marshall)(item.delete),
                     },
                 };
             }
             throw new Error('Invalid batch write item');
         });
-        const command = new BatchWriteItemCommand({
+        const command = new client_dynamodb_1.BatchWriteItemCommand({
             RequestItems: {
                 [tableName]: requests,
             },
@@ -150,10 +224,10 @@ export class DynamoDBClientWrapper {
      * Batch get (obtener múltiples items)
      */
     async batchGet(tableName, keys) {
-        const command = new BatchGetItemCommand({
+        const command = new client_dynamodb_1.BatchGetItemCommand({
             RequestItems: {
                 [tableName]: {
-                    Keys: keys.map((key) => marshall(key)),
+                    Keys: keys.map((key) => (0, util_dynamodb_1.marshall)(key)),
                 },
             },
         });
@@ -161,6 +235,89 @@ export class DynamoDBClientWrapper {
         if (!response.Responses || !response.Responses[tableName]) {
             return [];
         }
-        return response.Responses[tableName].map((item) => unmarshall(item));
+        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/index.d.ts

@@ -1 +1,2 @@
 export * from './dynamodb.client.js';
+export * from './modules/index.js';

package/dist/dynamodb/index.js

@@ -1 +1,18 @@
-export * from './dynamodb.client.js';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dynamodb.client.js"), exports);
+__exportStar(require("./modules/index.js"), exports);

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

@@ -0,0 +1,59 @@
+import type { Chat, Message, ChatWithMessages } from './types.js';
+import type { PaginatedResult, PaginationParams } from '../shared-types.js';
+export declare class ChatService {
+    private client;
+    private tableName;
+    constructor(tableName?: string, region?: string);
+    /**
+     * Crea un nuevo chat
+     */
+    createChat(chat: Omit<Chat, 'createdAt' | 'updatedAt'>): Promise<Chat>;
+    /**
+     * Obtiene un chat por ID
+     */
+    getChat(chatId: string): Promise<Chat | null>;
+    /**
+     * Actualiza un chat
+     */
+    updateChat(chatId: string, updates: Partial<Omit<Chat, 'chatId' | 'createdAt'>>): Promise<Chat>;
+    /**
+     * Elimina un chat y todos sus mensajes
+     */
+    deleteChat(chatId: string): Promise<void>;
+    /**
+     * Agrega un mensaje a un chat
+     */
+    addMessage(chatId: string, message: Omit<Message, 'chatId'>): Promise<Message>;
+    /**
+     * Obtiene mensajes de un chat (paginados)
+     */
+    getMessages(chatId: string, params?: PaginationParams): Promise<PaginatedResult<Message>>;
+    /**
+     * Obtiene los últimos N mensajes de un chat
+     */
+    getLastMessages(chatId: string, count?: number): Promise<Message[]>;
+    /**
+     * Obtiene todos los mensajes de un chat (sin paginación)
+     */
+    private getAllMessages;
+    /**
+     * Obtiene un chat con sus mensajes
+     */
+    getChatWithMessages(chatId: string, messageLimit?: number): Promise<ChatWithMessages | null>;
+    /**
+     * Lista chats por business y status (paginados)
+     */
+    listChatsByBusiness(businessId: string, status: string, params?: PaginationParams): Promise<PaginatedResult<Chat>>;
+    /**
+     * Lista todos los chats de un business (todos los status)
+     */
+    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
+     */
+    markAsRead(chatId: string): Promise<void>;
+}