@rempays/shared-core 1.0.2-beta.1

package/dist/cognito/cognito.service.js

@@ -0,0 +1,180 @@
+import { CognitoIdentityProviderClient, SignUpCommand, InitiateAuthCommand, RespondToAuthChallengeCommand, ConfirmSignUpCommand, GetUserCommand, AdminGetUserCommand, AdminInitiateAuthCommand, AuthFlowType, ChallengeNameType, } from '@aws-sdk/client-cognito-identity-provider';
+export class CognitoService {
+    constructor(config) {
+        this.config = config;
+        this.client = new CognitoIdentityProviderClient({
+            region: config.region,
+        });
+    }
+    /**
+     * Registra un nuevo usuario en Cognito
+     */
+    async signUp(params) {
+        const { phoneNumber, email, password } = params;
+        const userAttributes = [
+            { Name: 'phone_number', Value: phoneNumber },
+        ];
+        if (email) {
+            userAttributes.push({ Name: 'email', Value: email });
+        }
+        const command = new SignUpCommand({
+            ClientId: this.config.clientId,
+            Username: phoneNumber,
+            Password: password,
+            UserAttributes: userAttributes,
+        });
+        const response = await this.client.send(command);
+        return {
+            userSub: response.UserSub,
+            codeDeliveryDetails: response.CodeDeliveryDetails,
+        };
+    }
+    /**
+     * Confirma el registro de un usuario con el código OTP
+     */
+    async confirmSignUp(phoneNumber, code) {
+        const command = new ConfirmSignUpCommand({
+            ClientId: this.config.clientId,
+            Username: phoneNumber,
+            ConfirmationCode: code,
+        });
+        await this.client.send(command);
+    }
+    /**
+     * Inicia sesión con autenticación personalizada (CUSTOM_AUTH)
+     */
+    async signInCustomAuth(params) {
+        const { phoneNumber } = params;
+        const command = new InitiateAuthCommand({
+            ClientId: this.config.clientId,
+            AuthFlow: AuthFlowType.CUSTOM_AUTH,
+            AuthParameters: {
+                USERNAME: phoneNumber,
+            },
+        });
+        const response = await this.client.send(command);
+        return {
+            session: response.Session,
+            challengeName: response.ChallengeName,
+            challengeParameters: response.ChallengeParameters,
+        };
+    }
+    /**
+     * Inicia sesión con SRP (Secure Remote Password)
+     */
+    async signInSRP(params) {
+        const { phoneNumber } = params;
+        const command = new InitiateAuthCommand({
+            ClientId: this.config.clientId,
+            AuthFlow: AuthFlowType.USER_SRP_AUTH,
+            AuthParameters: {
+                USERNAME: phoneNumber,
+            },
+        });
+        const response = await this.client.send(command);
+        return {
+            session: response.Session,
+            challengeName: response.ChallengeName,
+            challengeParameters: response.ChallengeParameters,
+            accessToken: response.AuthenticationResult?.AccessToken,
+            idToken: response.AuthenticationResult?.IdToken,
+            refreshToken: response.AuthenticationResult?.RefreshToken,
+        };
+    }
+    /**
+     * Responde al desafío de autenticación (ej: verificar código OTP)
+     */
+    async respondToAuthChallenge(params) {
+        const { phoneNumber, code, session } = params;
+        const command = new RespondToAuthChallengeCommand({
+            ClientId: this.config.clientId,
+            ChallengeName: ChallengeNameType.CUSTOM_CHALLENGE,
+            Session: session,
+            ChallengeResponses: {
+                USERNAME: phoneNumber,
+                ANSWER: code,
+            },
+        });
+        const response = await this.client.send(command);
+        return {
+            accessToken: response.AuthenticationResult?.AccessToken,
+            idToken: response.AuthenticationResult?.IdToken,
+            refreshToken: response.AuthenticationResult?.RefreshToken,
+            session: response.Session,
+            challengeName: response.ChallengeName,
+        };
+    }
+    /**
+     * Refresca el token de acceso usando el refresh token
+     */
+    async refreshToken(params) {
+        const { refreshToken } = params;
+        const command = new InitiateAuthCommand({
+            ClientId: this.config.clientId,
+            AuthFlow: AuthFlowType.REFRESH_TOKEN_AUTH,
+            AuthParameters: {
+                REFRESH_TOKEN: refreshToken,
+            },
+        });
+        const response = await this.client.send(command);
+        return {
+            accessToken: response.AuthenticationResult?.AccessToken,
+            idToken: response.AuthenticationResult?.IdToken,
+        };
+    }
+    /**
+     * Obtiene información del usuario autenticado usando el access token
+     */
+    async getUser(accessToken) {
+        const command = new GetUserCommand({
+            AccessToken: accessToken,
+        });
+        const response = await this.client.send(command);
+        const attributes = {};
+        response.UserAttributes?.forEach((attr) => {
+            if (attr.Name && attr.Value) {
+                attributes[attr.Name] = attr.Value;
+            }
+        });
+        return attributes;
+    }
+    /**
+     * Obtiene información del usuario por username (requiere permisos de admin)
+     */
+    async adminGetUser(phoneNumber) {
+        const command = new AdminGetUserCommand({
+            UserPoolId: this.config.userPoolId,
+            Username: phoneNumber,
+        });
+        const response = await this.client.send(command);
+        const attributes = {};
+        response.UserAttributes?.forEach((attr) => {
+            if (attr.Name && attr.Value) {
+                attributes[attr.Name] = attr.Value;
+            }
+        });
+        return attributes;
+    }
+    /**
+     * Inicia autenticación como admin (útil para backend)
+     */
+    async adminInitiateAuth(phoneNumber) {
+        const command = new AdminInitiateAuthCommand({
+            UserPoolId: this.config.userPoolId,
+            ClientId: this.config.clientId,
+            AuthFlow: AuthFlowType.CUSTOM_AUTH,
+            AuthParameters: {
+                USERNAME: phoneNumber,
+            },
+        });
+        const response = await this.client.send(command);
+        return {
+            session: response.Session,
+            challengeName: response.ChallengeName,
+            challengeParameters: response.ChallengeParameters,
+            accessToken: response.AuthenticationResult?.AccessToken,
+            idToken: response.AuthenticationResult?.IdToken,
+            refreshToken: response.AuthenticationResult?.RefreshToken,
+        };
+    }
+}

package/dist/cognito/index.d.ts

@@ -0,0 +1,2 @@
+export { CognitoService } from './cognito.service';
+export * from './types';

package/dist/cognito/index.js

@@ -0,0 +1,2 @@
+export { CognitoService } from './cognito.service';
+export * from './types';

package/dist/cognito/types.d.ts

@@ -0,0 +1,38 @@
+export interface CognitoConfig {
+    userPoolId: string;
+    clientId: string;
+    region: string;
+}
+export interface SignUpParams {
+    phoneNumber: string;
+    email?: string;
+    password: string;
+}
+export interface SignInParams {
+    phoneNumber: string;
+    password?: string;
+}
+export interface VerifyCodeParams {
+    phoneNumber: string;
+    code: string;
+    session?: string;
+}
+export interface RefreshTokenParams {
+    refreshToken: string;
+}
+export interface AuthResponse {
+    accessToken?: string;
+    idToken?: string;
+    refreshToken?: string;
+    session?: string;
+    challengeName?: string;
+    challengeParameters?: Record<string, string>;
+}
+export interface UserAttributes {
+    sub?: string;
+    phone_number?: string;
+    email?: string;
+    phone_number_verified?: boolean;
+    email_verified?: boolean;
+    [key: string]: string | boolean | undefined;
+}

package/dist/cognito/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,67 @@
+/**
+ * Cliente genérico de DynamoDB
+ * Wrapper type-safe sobre AWS SDK
+ */
+export interface DynamoDBConfig {
+    region?: string;
+    endpoint?: string;
+}
+export interface PutItemOptions {
+    conditionExpression?: string;
+    expressionAttributeNames?: Record<string, string>;
+    expressionAttributeValues?: Record<string, any>;
+}
+export interface UpdateItemOptions {
+    updateExpression: string;
+    conditionExpression?: string;
+    expressionAttributeNames?: Record<string, string>;
+    expressionAttributeValues?: Record<string, any>;
+}
+export interface QueryOptions {
+    indexName?: string;
+    keyConditionExpression: string;
+    filterExpression?: string;
+    expressionAttributeNames?: Record<string, string>;
+    expressionAttributeValues?: Record<string, any>;
+    limit?: number;
+    scanIndexForward?: boolean;
+}
+export declare class DynamoDBClientWrapper {
+    private client;
+    constructor(config?: DynamoDBConfig);
+    /**
+     * Inserta o actualiza un item
+     */
+    put<T extends Record<string, any>>(tableName: string, item: T, options?: PutItemOptions): Promise<void>;
+    /**
+     * Obtiene un item por su clave primaria
+     */
+    get<T extends Record<string, any>>(tableName: string, key: Record<string, any>): Promise<T | null>;
+    /**
+     * Actualiza un item
+     */
+    update<T extends Record<string, any>>(tableName: string, key: Record<string, any>, options: UpdateItemOptions): Promise<T>;
+    /**
+     * Elimina un item
+     */
+    delete(tableName: string, key: Record<string, any>): Promise<void>;
+    /**
+     * Query con índice o clave primaria
+     */
+    query<T extends Record<string, any>>(tableName: string, options: QueryOptions): Promise<T[]>;
+    /**
+     * Scan completo de la tabla (usar con cuidado)
+     */
+    scan<T extends Record<string, any>>(tableName: string, limit?: number): Promise<T[]>;
+    /**
+     * Batch write (put o delete múltiples items)
+     */
+    batchWrite(tableName: string, items: Array<{
+        put?: Record<string, any>;
+        delete?: Record<string, any>;
+    }>): Promise<void>;
+    /**
+     * Batch get (obtener múltiples items)
+     */
+    batchGet<T extends Record<string, any>>(tableName: string, keys: Array<Record<string, any>>): Promise<T[]>;
+}

package/dist/dynamodb/dynamodb.client.js

@@ -0,0 +1,166 @@
+/**
+ * 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 {
+    constructor(config = {}) {
+        this.client = new DynamoDBClient({
+            region: config.region || process.env.AWS_REGION || 'us-east-1',
+            ...(config.endpoint && { endpoint: config.endpoint }),
+        });
+    }
+    /**
+     * Inserta o actualiza un item
+     */
+    async put(tableName, item, options) {
+        const command = new PutItemCommand({
+            TableName: tableName,
+            Item: marshall(item, { removeUndefinedValues: true }),
+            ...(options?.conditionExpression && {
+                ConditionExpression: options.conditionExpression,
+            }),
+            ...(options?.expressionAttributeNames && {
+                ExpressionAttributeNames: options.expressionAttributeNames,
+            }),
+            ...(options?.expressionAttributeValues && {
+                ExpressionAttributeValues: marshall(options.expressionAttributeValues),
+            }),
+        });
+        await this.client.send(command);
+    }
+    /**
+     * Obtiene un item por su clave primaria
+     */
+    async get(tableName, key) {
+        const command = new GetItemCommand({
+            TableName: tableName,
+            Key: marshall(key),
+        });
+        const response = await this.client.send(command);
+        if (!response.Item) {
+            return null;
+        }
+        return unmarshall(response.Item);
+    }
+    /**
+     * Actualiza un item
+     */
+    async update(tableName, key, options) {
+        const command = new UpdateItemCommand({
+            TableName: tableName,
+            Key: marshall(key),
+            UpdateExpression: options.updateExpression,
+            ...(options.conditionExpression && {
+                ConditionExpression: options.conditionExpression,
+            }),
+            ...(options.expressionAttributeNames && {
+                ExpressionAttributeNames: options.expressionAttributeNames,
+            }),
+            ...(options.expressionAttributeValues && {
+                ExpressionAttributeValues: marshall(options.expressionAttributeValues),
+            }),
+            ReturnValues: 'ALL_NEW',
+        });
+        const response = await this.client.send(command);
+        return unmarshall(response.Attributes);
+    }
+    /**
+     * Elimina un item
+     */
+    async delete(tableName, key) {
+        const command = new DeleteItemCommand({
+            TableName: tableName,
+            Key: marshall(key),
+        });
+        await this.client.send(command);
+    }
+    /**
+     * Query con índice o clave primaria
+     */
+    async query(tableName, options) {
+        const command = new QueryCommand({
+            TableName: tableName,
+            ...(options.indexName && { IndexName: options.indexName }),
+            KeyConditionExpression: options.keyConditionExpression,
+            ...(options.filterExpression && {
+                FilterExpression: options.filterExpression,
+            }),
+            ...(options.expressionAttributeNames && {
+                ExpressionAttributeNames: options.expressionAttributeNames,
+            }),
+            ...(options.expressionAttributeValues && {
+                ExpressionAttributeValues: marshall(options.expressionAttributeValues),
+            }),
+            ...(options.limit && { Limit: options.limit }),
+            ...(options.scanIndexForward !== undefined && {
+                ScanIndexForward: options.scanIndexForward,
+            }),
+        });
+        const response = await this.client.send(command);
+        if (!response.Items || response.Items.length === 0) {
+            return [];
+        }
+        return response.Items.map((item) => unmarshall(item));
+    }
+    /**
+     * Scan completo de la tabla (usar con cuidado)
+     */
+    async scan(tableName, limit) {
+        const command = new ScanCommand({
+            TableName: tableName,
+            ...(limit && { Limit: limit }),
+        });
+        const response = await this.client.send(command);
+        if (!response.Items || response.Items.length === 0) {
+            return [];
+        }
+        return response.Items.map((item) => unmarshall(item));
+    }
+    /**
+     * Batch write (put o delete múltiples items)
+     */
+    async batchWrite(tableName, items) {
+        const requests = items.map((item) => {
+            if (item.put) {
+                return {
+                    PutRequest: {
+                        Item: marshall(item.put, { removeUndefinedValues: true }),
+                    },
+                };
+            }
+            else if (item.delete) {
+                return {
+                    DeleteRequest: {
+                        Key: marshall(item.delete),
+                    },
+                };
+            }
+            throw new Error('Invalid batch write item');
+        });
+        const command = new BatchWriteItemCommand({
+            RequestItems: {
+                [tableName]: requests,
+            },
+        });
+        await this.client.send(command);
+    }
+    /**
+     * Batch get (obtener múltiples items)
+     */
+    async batchGet(tableName, keys) {
+        const command = new BatchGetItemCommand({
+            RequestItems: {
+                [tableName]: {
+                    Keys: keys.map((key) => marshall(key)),
+                },
+            },
+        });
+        const response = await this.client.send(command);
+        if (!response.Responses || !response.Responses[tableName]) {
+            return [];
+        }
+        return response.Responses[tableName].map((item) => unmarshall(item));
+    }
+}

package/dist/dynamodb/index.d.ts

@@ -0,0 +1 @@
+export * from './dynamodb.client.js';

package/dist/dynamodb/index.js

@@ -0,0 +1 @@
+export * from './dynamodb.client.js';

package/dist/facebook-api/facebook.d.ts

@@ -0,0 +1,83 @@
+export interface SendTextParams {
+    to: string;
+    body: string;
+    previewUrl?: boolean;
+}
+export interface SendTemplateParams {
+    to: string;
+    name: string;
+    languageCode: string;
+    components?: any[];
+}
+export interface SendInteractiveParams {
+    to: string;
+    header?: {
+        type: "text";
+        text: string;
+    };
+    body: string;
+    footer?: string;
+    buttons: Array<{
+        type: "reply";
+        id: string;
+        title: string;
+    }>;
+}
+export interface SendInteractiveListParams {
+    to: string;
+    header?: {
+        type: "text";
+        text: string;
+    };
+    body: string;
+    footer?: string;
+    buttonText: string;
+    sections: Array<{
+        title: string;
+        rows: Array<{
+            id: string;
+            title: string;
+            description?: string;
+        }>;
+    }>;
+}
+export interface SendImageParams {
+    to: string;
+    link: string;
+    caption?: string;
+}
+export interface SendDocumentParams {
+    to: string;
+    link: string;
+    filename?: string;
+    caption?: string;
+}
+export interface SendLocationParams {
+    to: string;
+    latitude: number;
+    longitude: number;
+    name?: string;
+    address?: string;
+}
+export interface SetTypingParams {
+    messageId: string;
+}
+export interface MarkAsReadParams {
+    messageId: string;
+}
+export declare class FacebookApi {
+    private static token;
+    private static phoneNumberId;
+    private static apiVersion;
+    private static init;
+    private static post;
+    static sendText(params: SendTextParams): Promise<any>;
+    static sendTemplate(params: SendTemplateParams): Promise<any>;
+    static sendInteractiveButtons(params: SendInteractiveParams): Promise<any>;
+    static sendInteractiveList(params: SendInteractiveListParams): Promise<any>;
+    static sendImage(params: SendImageParams): Promise<any>;
+    static sendDocument(params: SendDocumentParams): Promise<any>;
+    static sendLocation(params: SendLocationParams): Promise<any>;
+    static setTyping(params: SetTypingParams): Promise<any>;
+    static markAsRead(params: MarkAsReadParams): Promise<any>;
+}