@leaderty/index-variations 1.0.1

package/README.md

@@ -0,0 +1,46 @@
+# @leaderty/index-variations
+
+Paquete para obtener variaciones de índices económicos de Argentina (IPC) mediante un cron job diario.
+
+## Comandos
+
+```bash
+# Build
+pnpm build
+
+# Test
+pnpm test
+```
+
+## Funciones
+
+### `startIndexCronJob(cb, hour, fetchOnStartup?)`
+
+Inicia un cron job que obtiene los índices diariamente a la hora especificada (zona horaria Argentina).
+
+**Parámetros:**
+- `cb` - Función callback que se ejecuta al obtener cada índice
+- `hour` - Hora del día para ejecutar el cron (0-23)
+- `fetchOnStartup` - Opcional, ejecuta el fetch inmediatamente al iniciar (default: `true`)
+
+**Retorna:** `Promise<CronJob>`
+
+### `getIPCVariation()`
+
+Obtiene la variación del IPC desde la API externa.
+
+**Retorna:** `Promise<{ value: number; date: Date }>`
+
+**Throws:** Error si la API retorna datos inválidos o con formato incorrecto
+
+## Types
+
+```typescript
+interface IIndex {
+  index: string;    // Nombre del índice (ej: 'IPC')
+  date: Date;       // Fecha de publicación
+  value: number;    // Valor del índice
+}
+
+type Callback = (index: IIndex) => Promise<void>
+```

package/dist/api.d.ts

@@ -0,0 +1,5 @@
+export declare function getIPCVariation(): Promise<{
+    value: number;
+    date: Date;
+}>;
+export declare function getRipteVariation(): Promise<number | null>;

package/dist/api.js

@@ -0,0 +1,66 @@
+import * as z from 'zod';
+import * as https from 'https';
+import * as cheerio from 'cheerio';
+const RIPTE_URL = 'https://www.argentina.gob.ar/trabajo/seguridadsocial/ripte';
+const IPC_URL = 'https://api.argly.com.ar/api/ipc/';
+export async function getIPCVariation() {
+    const response = await fetch(IPC_URL);
+    const data = await response.json();
+    if (!data || !data.data)
+        throw new Error("Invalid IPC data");
+    const ipcSchema = z.object({
+        indice_ipc: z.number(),
+        mes: z.number(),
+        nombre_mes: z.string(),
+        anio: z.number(),
+        fecha_publicacion: z.string(),
+        fecha_proximo_informe: z.string()
+    });
+    const parsed = ipcSchema.safeParse(data.data);
+    if (!parsed.success)
+        throw new Error("Invalid IPC data");
+    // Format date from "DD/MM/YYYY" to Date object
+    const dateParts = parsed.data.fecha_publicacion.split('/');
+    if (dateParts.length !== 3)
+        throw new Error("Invalid date format in IPC data");
+    const pubDate = new Date(parseInt(dateParts[2]), parsed.data.mes, parseInt(dateParts[0]));
+    return { value: parsed.data.indice_ipc, date: pubDate };
+}
+export async function getRipteVariation() {
+    return new Promise((resolve, reject) => {
+        https
+            .get(RIPTE_URL, (res) => {
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                try {
+                    const $ = cheerio.load(data);
+                    const element = $('td[data-label]')
+                        .filter((_, el) => {
+                        const label = $(el).attr('data-label');
+                        const normalized = label?.replace(/\s+/g, ' ').trim() || '';
+                        return normalized === 'Variación respecto mes anterior';
+                    })
+                        .first();
+                    const text = element.text().trim();
+                    const match = text.match(/[-+]?\d+,\d+/);
+                    if (match) {
+                        const value = parseFloat(match[0].replace(',', '.'));
+                        resolve(value);
+                    }
+                    else {
+                        resolve(null);
+                    }
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        })
+            .on('error', (error) => {
+            reject(error);
+        });
+    });
+}

package/dist/api.test.d.ts

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

package/dist/api.test.js

@@ -0,0 +1,140 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { getIPCVariation } from "./api";
+// Save the real fetch function before any mocking happens
+const realFetch = global.fetch;
+describe("getIPCVariation", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it("should fetch and parse IPC data correctly", async () => {
+        const mockData = {
+            data: {
+                indice_ipc: 123.45,
+                mes: 1,
+                nombre_mes: "Enero",
+                anio: 2024,
+                fecha_publicacion: "15/02/2024",
+                fecha_proximo_informe: "15/03/2024",
+            },
+        };
+        global.fetch = vi.fn().mockResolvedValueOnce({
+            json: vi.fn().mockResolvedValueOnce(mockData),
+        });
+        const result = await getIPCVariation();
+        expect(result.value).toBe(123.45);
+        expect(result.date).toBeInstanceOf(Date);
+        expect(global.fetch).toHaveBeenCalledWith("https://api.argly.com.ar/api/ipc/");
+    });
+    it("should throw error when data is missing", async () => {
+        global.fetch = vi.fn().mockResolvedValueOnce({
+            json: vi.fn().mockResolvedValueOnce({}),
+        });
+        await expect(getIPCVariation()).rejects.toThrow("Invalid IPC data");
+    });
+    it("should throw error when validation fails", async () => {
+        const mockData = {
+            data: {
+                indice_ipc: "not a number",
+                mes: 1,
+                nombre_mes: "Enero",
+                anio: 2024,
+                fecha_publicacion: "15/02/2024",
+                fecha_proximo_informe: "15/03/2024",
+            },
+        };
+        global.fetch = vi.fn().mockResolvedValueOnce({
+            json: vi.fn().mockResolvedValueOnce(mockData),
+        });
+        await expect(getIPCVariation()).rejects.toThrow("Invalid IPC data");
+    });
+    it("should throw error on invalid date format", async () => {
+        const mockData = {
+            data: {
+                indice_ipc: 123.45,
+                mes: 1,
+                nombre_mes: "Enero",
+                anio: 2024,
+                fecha_publicacion: "invalid-date",
+                fecha_proximo_informe: "15/03/2024",
+            },
+        };
+        global.fetch = vi.fn().mockResolvedValueOnce({
+            json: vi.fn().mockResolvedValueOnce(mockData),
+        });
+        await expect(getIPCVariation()).rejects.toThrow("Invalid date format in IPC data");
+    });
+    // INTEGRATION TEST: Real API call to validate response structure
+    // Run this periodically to ensure the API contract hasn't changed
+    it.skip("should fetch real IPC data and validate structure", async () => {
+        // Restore real fetch for this integration test
+        global.fetch = realFetch;
+        const result = await getIPCVariation();
+        // Validate return type
+        expect(result).toHaveProperty("value");
+        expect(result).toHaveProperty("date");
+        expect(typeof result.value).toBe("number");
+        expect(result.date).toBeInstanceOf(Date);
+        // Validate value is reasonable for IPC index
+        expect(result.value).toBeGreaterThan(0);
+        expect(result.value).toBeLessThan(10000);
+        // Validate date is recent (within last 60 days)
+        const daysSinceUpdate = (new Date().getTime() - result.date.getTime()) / (1000 * 60 * 60 * 24);
+        expect(daysSinceUpdate).toBeLessThan(60);
+    });
+});
+describe("getRipteVariation", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it("should fetch RIPTE variation from HTML", async () => {
+        const mockHtml = `
+      <table>
+        <tr>
+          <td data-label="Variación respecto mes anterior">5.50</td>
+        </tr>
+      </table>
+    `;
+        const mockHttpsGet = vi.fn((url, callback) => {
+            const mockResponse = {
+                on: vi.fn((event, handler) => {
+                    if (event === "data") {
+                        handler(mockHtml);
+                    }
+                    else if (event === "end") {
+                        handler();
+                    }
+                }),
+            };
+            callback(mockResponse);
+        });
+        vi.doMock("https", () => ({
+            default: { get: mockHttpsGet },
+            get: mockHttpsGet,
+        }));
+        // Note: This test would need proper HTTPS mocking
+        // The actual implementation uses https.get which is harder to mock
+    });
+    it("should handle when no matching element is found", async () => {
+        const mockHttpsGet = vi.fn((url, callback) => {
+            const mockResponse = {
+                on: vi.fn((event, handler) => {
+                    if (event === "data") {
+                        handler("<html></html>");
+                    }
+                    else if (event === "end") {
+                        handler();
+                    }
+                }),
+            };
+            callback(mockResponse);
+        });
+        // Note: This test would need proper HTTPS mocking
+        // The actual implementation uses https.get which is harder to mock
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import { CronJob } from 'cron';
+export interface IIndex {
+    index: string;
+    date: Date;
+    value: number;
+}
+type Callback = (index: IIndex) => Promise<void>;
+/**
+ * Starts a cron job that fetches all indexes every day at the specified hour Argentina time.
+ * Can execute immediately on startup and then at the specified hour daily.
+ * @param cb - Callback function to run on each fetched index
+ * @param hour - Hour at which to run the cron job (Argentina time)
+ * @param fetchOnStartup - Whether to fetch indexes immediately on startup
+ * @returns The created CronJob instance
+ */
+export declare function startIndexCronJob(cb: Callback, hour: number, fetchOnStartup?: boolean): Promise<CronJob>;
+export {};

package/dist/index.js

@@ -0,0 +1,37 @@
+import { CronJob } from 'cron';
+import { getIPCVariation } from './api';
+/**
+ * Fetches and saves all indexes to the database.
+ * @param cb - Callback function to run on each fetched index
+ */
+async function fetchIndexes(cb) {
+    try {
+        console.log('[INDEX] Fetching indexes...');
+        // Fetch IPC (available index)
+        const { value, date } = await getIPCVariation();
+        await cb({ index: 'IPC', date, value });
+        console.log(`[INDEX] IPC saved: ${value}`);
+        // Future: add more indexes here as they become available
+        // const { value: ripteValue, date: ripteDate } = await getRipteVariation()
+        // await cb({ index: 'RIPTE', date: ripteDate, value: ripteValue })
+    }
+    catch (error) {
+        console.error('[INDEX] Unexpected error:', error);
+    }
+}
+/**
+ * Starts a cron job that fetches all indexes every day at the specified hour Argentina time.
+ * Can execute immediately on startup and then at the specified hour daily.
+ * @param cb - Callback function to run on each fetched index
+ * @param hour - Hour at which to run the cron job (Argentina time)
+ * @param fetchOnStartup - Whether to fetch indexes immediately on startup
+ * @returns The created CronJob instance
+ */
+export async function startIndexCronJob(cb, hour, fetchOnStartup = true) {
+    // Execute immediately on startup
+    if (fetchOnStartup)
+        await fetchIndexes(cb);
+    const job = new CronJob(`0 ${hour} * * *`, () => fetchIndexes(cb), null, true, 'America/Argentina/Buenos_Aires');
+    console.log(`[INDEX] Index cron job started (${hour} AM Argentina)`);
+    return job;
+}

package/dist/index.test.d.ts

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

package/dist/index.test.js

@@ -0,0 +1,56 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { startIndexCronJob } from "./index";
+import * as apiModule from "./api";
+vi.mock("./api");
+vi.mock("cron");
+describe("startIndexCronJob", () => {
+    let mockCallback;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockCallback = vi.fn().mockResolvedValue(undefined);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it("should fetch indexes on startup and call callback with IPC data", async () => {
+        const mockDate = new Date("2024-01-15");
+        const mockValue = 3.5;
+        vi.mocked(apiModule.getIPCVariation).mockResolvedValueOnce({
+            value: mockValue,
+            date: mockDate,
+        });
+        await startIndexCronJob(mockCallback, 8, true);
+        expect(mockCallback).toHaveBeenCalledOnce();
+        expect(mockCallback).toHaveBeenCalledWith({
+            index: "IPC",
+            date: mockDate,
+            value: mockValue,
+        });
+    });
+    it("should not fetch indexes on startup when fetchOnStartup is false", async () => {
+        await startIndexCronJob(mockCallback, 8, false);
+        expect(mockCallback).not.toHaveBeenCalled();
+    });
+    it("should create cron job with correct schedule for different hours", async () => {
+        const testHours = [8, 14, 23];
+        for (const hour of testHours) {
+            vi.clearAllMocks();
+            vi.mocked(apiModule.getIPCVariation).mockResolvedValueOnce({
+                value: 2.5,
+                date: new Date(),
+            });
+            const result = await startIndexCronJob(mockCallback, hour);
+            const { CronJob } = await import("cron");
+            expect(vi.mocked(CronJob)).toHaveBeenCalledWith(`0 ${hour} * * *`, expect.any(Function), null, true, "America/Argentina/Buenos_Aires");
+            expect(result).toBeDefined();
+        }
+    });
+    it("should handle API errors gracefully and skip callback", async () => {
+        const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        vi.mocked(apiModule.getIPCVariation).mockRejectedValueOnce(new Error("API Error"));
+        await startIndexCronJob(mockCallback, 8);
+        expect(consoleErrorSpy).toHaveBeenCalledWith("[INDEX] Unexpected error:", expect.any(Error));
+        expect(mockCallback).not.toHaveBeenCalled();
+        consoleErrorSpy.mockRestore();
+    });
+});

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@leaderty/index-variations",
+  "version": "1.0.1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "cheerio": "^1.2.0",
+    "cron": "^4.4.0",
+    "https": "^1.0.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run"
+  }
+}