plenna_utilities 1.11.0 → 1.13.0

package/dist/index.d.ts

@@ -9,3 +9,4 @@ export * from './src/airTable';
 export * from './src/alerts/presenter';
 export * from './src/common/domain/shared';
 export * from './src/AI/bedrock';
+export * from './src/respira';

package/dist/index.js

@@ -30,3 +30,4 @@ __exportStar(require("./src/airTable"), exports);
 __exportStar(require("./src/alerts/presenter"), exports);
 __exportStar(require("./src/common/domain/shared"), exports);
 __exportStar(require("./src/AI/bedrock"), exports);
+__exportStar(require("./src/respira"), exports);

package/dist/src/airTable/index.d.ts

@@ -1,5 +1,21 @@
+import { type FieldSet, type Records } from 'airtable';
+export type { FieldSet } from 'airtable';
+export type { Records } from 'airtable';
 export declare class AirTable {
     private readonly webhook;
     constructor(webhook: string);
     sendToAirTable(payload: Record<string, unknown>): Promise<boolean>;
 }
+export declare class AirtableAPI {
+    private readonly apiKey;
+    private readonly baseId;
+    private readonly tableName;
+    constructor(apiKey: string, baseId: string, tableName: string);
+    getRecords(valuesToSearch: string[], fieldToSearch: string, maxRecords: number, view?: string, options?: {
+        fields?: string[];
+    }): Promise<Array<Records<FieldSet>[number]>>;
+    updateRecords(records: Array<{
+        id: string;
+        fields: Record<string, unknown>;
+    }>): Promise<void>;
+}

package/dist/src/airTable/index.js

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AirTable = void 0;
+exports.AirtableAPI = exports.AirTable = void 0;
+const airtable_1 = __importDefault(require("airtable"));
 class AirTable {
     webhook;
     constructor(webhook) {
@@ -25,3 +29,54 @@ class AirTable {
     }
 }
 exports.AirTable = AirTable;
+class AirtableAPI {
+    apiKey;
+    baseId;
+    tableName;
+    constructor(apiKey, baseId, tableName) {
+        this.apiKey = apiKey;
+        this.baseId = baseId;
+        this.tableName = tableName;
+    }
+    async getRecords(valuesToSearch, fieldToSearch, maxRecords, view, options) {
+        return await new Promise((resolve, reject) => {
+            const base = new airtable_1.default({ apiKey: this.apiKey }).base(this.baseId);
+            const allRecords = [];
+            const filterByFormula = valuesToSearch.length === 1
+                ? `{${fieldToSearch}} = '${valuesToSearch[0]}'`
+                : `OR(${valuesToSearch.map(v => `{${fieldToSearch}} = '${v}'`).join(', ')})`;
+            base(this.tableName)
+                .select({ filterByFormula, maxRecords, view: view ?? 'Grid view', ...options })
+                .eachPage((records, fetchNextPage) => {
+                console.log('records: ', records);
+                allRecords.push(...records);
+                fetchNextPage();
+            }, (err) => {
+                if (err !== null) {
+                    console.error('❌ Error de Airtable:', err);
+                    reject(err);
+                    return;
+                }
+                resolve(allRecords);
+            });
+        });
+    }
+    async updateRecords(records) {
+        const base = new airtable_1.default({ apiKey: this.apiKey }).base(this.baseId);
+        const chunkSize = 10;
+        for (let i = 0; i < records.length; i += chunkSize) {
+            const batch = records.slice(i, i + chunkSize).map((record) => (record));
+            console.log(`Actualizando batch ${i / chunkSize + 1}...`);
+            try {
+                await base(this.tableName).update(batch);
+                console.log(`✅ Update completado del batch ${i / chunkSize + 1}`);
+            }
+            catch (error) {
+                console.error('❌ Error de Airtable:', error);
+                throw error;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 200));
+        }
+    }
+}
+exports.AirtableAPI = AirtableAPI;

package/dist/src/customerio/index.d.ts

@@ -6,4 +6,6 @@ export declare class CustomerIo {
     constructor(key: string);
     sendPushNotification(requestOptions: PushRequestOptions): Promise<boolean>;
     sendEmail(requestOptions: EmailRequestOptions): Promise<boolean>;
+    sendPushNotificationWithResponse(requestOptions: PushRequestOptions): Promise<Record<string, unknown>>;
+    sendEmailWithResponse(requestOptions: EmailRequestOptions): Promise<Record<string, unknown>>;
 }

package/dist/src/customerio/index.js

@@ -33,5 +33,31 @@ class CustomerIo {
             return false;
         }
     }
+    async sendPushNotificationWithResponse(requestOptions) {
+        try {
+            const request = new customerio_node_1.SendPushRequest(requestOptions);
+            const api = new customerio_node_1.APIClient(this.key, { region: customerio_node_1.RegionUS });
+            const response = await api.sendPush(request);
+            console.log('Sent push notification success: ', response);
+            return response;
+        }
+        catch (error) {
+            console.error('Failed to send push notification: ', error);
+            return { error };
+        }
+    }
+    async sendEmailWithResponse(requestOptions) {
+        try {
+            const request = new customerio_node_1.SendEmailRequest(requestOptions);
+            const api = new customerio_node_1.APIClient(this.key, { region: customerio_node_1.RegionUS });
+            const response = await api.sendEmail(request);
+            console.log('Sent email success: ', response);
+            return response;
+        }
+        catch (error) {
+            console.error('Failed to send email: ', error);
+            return { error };
+        }
+    }
 }
 exports.CustomerIo = CustomerIo;

package/dist/src/google/index.d.ts

@@ -1,4 +1,5 @@
 import { docs_v1 } from '@googleapis/docs';
+import { calendar_v3 } from '@googleapis/calendar';
 import { GoogleAuth, type JWTInput } from 'google-auth-library';
 import { type JSONClient } from 'google-auth-library/build/src/auth/googleauth';
 import { type IPlennaGoogleBase } from './requestBuilder';
@@ -14,6 +15,50 @@ interface deleteDocumentResponse {
     success: boolean;
     documentId?: string;
 }
+interface createCalendarEventResponse {
+    success: boolean;
+    event?: calendar_v3.Schema$Event;
+}
+interface deleteCalendarEventResponse {
+    success: boolean;
+    eventId?: string;
+}
+interface updateCalendarEventResponse {
+    success: boolean;
+    event?: calendar_v3.Schema$Event;
+}
+export interface IRescheduleEvent {
+    start: {
+        dateTime?: string;
+        date?: string;
+        timeZone?: string;
+    };
+    end: {
+        dateTime?: string;
+        date?: string;
+        timeZone?: string;
+    };
+}
+export interface ICalendarEventInsertParameters {
+    calendarId: string;
+    conferenceDataVersion: number;
+    maxAttendees: number;
+    sendNotifications: boolean;
+    sendUpdates: 'all' | 'externalOnly' | 'none';
+    supportsAttachments: boolean;
+}
+export interface ICalendarEventPatchParameters {
+    calendarId: string;
+    eventId: string;
+    alwaysIncludeEmail?: boolean;
+    conferenceDataVersion?: number;
+    maxAttendees?: number;
+    sendNotifications?: boolean;
+    sendUpdates?: 'all' | 'externalOnly' | 'none';
+    supportsAttachments?: boolean;
+}
+export interface ICalendarEvent extends calendar_v3.Schema$Event {
+}
 export interface ISchemaRequest extends docs_v1.Schema$Request {
 }
 export interface IInsertText extends docs_v1.Schema$InsertTextRequest {
@@ -24,8 +69,12 @@ export interface ICredentials extends JWTInput {
 }
 export declare class PlennaGoogleService {
     private readonly credentials;
-    constructor(credentials: ICredentials);
+    private readonly opts?;
+    constructor(credentials: ICredentials, opts?: {
+        subject?: string;
+    });
     authorization(): GoogleAuth<JSONClient>;
+    calendarAuthorization(): GoogleAuth<JSONClient>;
     getDocument(documentId: string): Promise<docs_v1.Schema$Document | undefined>;
     cloneDocument(documentId: string, folderId: string): Promise<cloneDocumentResponse>;
     buildPayload(template?: Array<Partial<IPlennaGoogleBase>>): ISchemaRequest[];
@@ -34,5 +83,8 @@ export declare class PlennaGoogleService {
     exportDocumentAsUrl(fileId: string): Promise<string | undefined>;
     exportDocumentAsFile(fileId: string): Promise<ArrayBuffer | undefined>;
     deleteDocument(fileId: string): Promise<deleteDocumentResponse>;
+    createCalendarEvent(parameterOptions: ICalendarEventInsertParameters, event: ICalendarEvent): Promise<createCalendarEventResponse>;
+    deleteCalendarEvent(eventId: string, calendarId?: string): Promise<deleteCalendarEventResponse>;
+    updateCalendarEvent(parameterOptions: ICalendarEventPatchParameters, updates: Partial<ICalendarEvent>): Promise<updateCalendarEventResponse>;
 }
 export {};

package/dist/src/google/index.js

@@ -3,11 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlennaGoogleService = void 0;
 const docs_1 = require("@googleapis/docs");
 const drive_1 = require("@googleapis/drive");
+const calendar_1 = require("@googleapis/calendar");
 const google_auth_library_1 = require("google-auth-library");
 const requestBuilder_1 = require("./requestBuilder");
 class PlennaGoogleService {
     credentials;
-    constructor(credentials) {
+    opts;
+    constructor(credentials, opts) {
+        this.opts = opts ?? null;
         this.credentials = credentials;
     }
     authorization() {
@@ -19,6 +22,17 @@ class PlennaGoogleService {
             ]
         });
     }
+    calendarAuthorization() {
+        return new google_auth_library_1.GoogleAuth({
+            credentials: this.credentials,
+            scopes: [
+                'https://www.googleapis.com/auth/calendar'
+            ],
+            clientOptions: {
+                subject: this.opts?.subject ?? ''
+            }
+        });
+    }
     async getDocument(documentId) {
         const authClient = this.authorization();
         const client = new docs_1.docs_v1.Docs({ auth: authClient });
@@ -114,5 +128,59 @@ class PlennaGoogleService {
             return { success: false };
         }
     }
+    async createCalendarEvent(parameterOptions, event) {
+        const authClient = this.calendarAuthorization();
+        const calendar = new calendar_1.calendar_v3.Calendar({ auth: authClient });
+        try {
+            const response = await calendar.events.insert({
+                ...parameterOptions,
+                requestBody: event
+            }, { headers: await authClient.getRequestHeaders() });
+            return {
+                success: true,
+                event: response.data
+            };
+        }
+        catch (error) {
+            console.log(error);
+            return { success: false };
+        }
+    }
+    async deleteCalendarEvent(eventId, calendarId = 'primary') {
+        const authClient = this.calendarAuthorization();
+        const calendar = new calendar_1.calendar_v3.Calendar({ auth: authClient });
+        try {
+            await calendar.events.delete({
+                calendarId,
+                eventId
+            }, { headers: await authClient.getRequestHeaders() });
+            return {
+                success: true,
+                eventId
+            };
+        }
+        catch (error) {
+            console.log(error);
+            return { success: false };
+        }
+    }
+    async updateCalendarEvent(parameterOptions, updates) {
+        const authClient = this.authorization();
+        const calendar = new calendar_1.calendar_v3.Calendar({ auth: authClient });
+        try {
+            const response = await calendar.events.patch({
+                ...parameterOptions,
+                requestBody: updates
+            }, { headers: await authClient.getRequestHeaders() });
+            return {
+                success: true,
+                event: response.data
+            };
+        }
+        catch (error) {
+            console.log(error);
+            return { success: false };
+        }
+    }
 }
 exports.PlennaGoogleService = PlennaGoogleService;

package/dist/src/respira/index.d.ts

@@ -0,0 +1,65 @@
+export interface IWhatsAppMessage {
+    phone: string;
+    name?: string;
+    email?: string;
+    ri_body_param_1?: string;
+    ri_body_param_2?: string;
+    ri_body_param_3?: string;
+    ri_body_param_4?: string;
+    ri_body_param_5?: string;
+    ri_body_param_6?: string;
+    ri_body_param_7?: string;
+    ri_body_param_8?: string;
+    ri_body_param_9?: string;
+    ri_body_param_10?: string;
+    ri_body_param_11?: string;
+    ri_body_param_12?: string;
+    ri_body_param_13?: string;
+    ri_body_param_14?: string;
+    ri_body_param_15?: string;
+    ri_body_param_16?: string;
+    ri_body_param_17?: string;
+    ri_body_param_18?: string;
+    ri_body_param_19?: string;
+    ri_body_param_20?: string;
+    ri_footer_param_1?: string;
+    ri_footer_param_2?: string;
+    ri_footer_param_3?: string;
+    ri_footer_param_4?: string;
+    ri_footer_param_5?: string;
+    ri_header_type?: string;
+    ri_header_text?: string;
+    ri_header_link?: string;
+    delivery_date?: string;
+    delivery_time?: string;
+    iana_timezone?: string;
+    tags?: string;
+}
+export interface ISendWhatsAppMessagesOptions {
+    template_name: string;
+    language: string;
+    omit_ticket_creation: string;
+    ticket_id?: number;
+    tags?: string;
+    add_to_queue?: boolean;
+    origin?: string;
+    subdomain?: string;
+    messages: IWhatsAppMessage[];
+}
+export interface IWhatsAppMessageDetailQuery {
+    id_single_notification: string;
+    phone?: string;
+    template_name?: string;
+    sunco_notification_id?: string;
+    origin?: string;
+    delivery_date_from?: string;
+    delivery_date_to?: string;
+}
+export declare class RespiraInternet {
+    private readonly apiKey;
+    private readonly username;
+    private readonly apiUrl;
+    constructor(apiKey: string, username: string, apiUrl: string);
+    sendWhatsAppMessages(options: ISendWhatsAppMessagesOptions): Promise<Response>;
+    getWhatsAppMessageDetail(query: IWhatsAppMessageDetailQuery): Promise<Response>;
+}

package/dist/src/respira/index.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RespiraInternet = void 0;
+class RespiraInternet {
+    apiKey;
+    username;
+    apiUrl;
+    constructor(apiKey, username, apiUrl) {
+        this.apiKey = apiKey;
+        this.username = username;
+        this.apiUrl = apiUrl;
+    }
+    sendWhatsAppMessages(options) {
+        const auth = Buffer.from(`${this.username}:${this.apiKey}`).toString('base64');
+        return fetch(`${this.apiUrl}/messages/`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Basic ${auth}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(options)
+        });
+    }
+    getWhatsAppMessageDetail(query) {
+        const params = {};
+        Object.entries(query).forEach(([key, value]) => {
+            if (value !== undefined) {
+                params[key] = value;
+            }
+        });
+        const queryString = new URLSearchParams(params).toString();
+        const auth = Buffer.from(`${this.username}:${this.apiKey}`).toString('base64');
+        return fetch(`${this.apiUrl}/messages?${queryString}`, {
+            method: 'GET',
+            headers: {
+                Authorization: `Basic ${auth}`,
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+}
+exports.RespiraInternet = RespiraInternet;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plenna_utilities",
-  "version": "1.11.0",
+  "version": "1.13.0",
   "description": "plenna's utils for backend projects",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -39,10 +39,12 @@
     "@aws-sdk/client-bedrock-runtime": "^3.600.0",
     "@aws-sdk/client-s3": "^3.600.0",
     "@aws-sdk/s3-request-presigner": "^3.600.0",
+    "@googleapis/calendar": "^14.2.0",
     "@googleapis/docs": "^3.0.2",
     "@googleapis/drive": "^8.10.0",
     "@googleapis/sheets": "^8.0.0",
     "@slack/web-api": "^6.9.1",
+    "airtable": "^0.12.2",
     "customerio-node": "^4.1.1",
     "dotenv": "^16.4.5",
     "google-auth-library": "^9.11.0",