@gamariverib/mercados-pecuarios-libs-analytical-reports 0.1.0

package/README.md

@@ -0,0 +1,5 @@
+# Mercados Pecuarios Analytical Reports Lib
+
+Biblioteca de clases comunes para el código en JavaScript/TypeScript para los servicios de Analytical Reports de la Plataforma Big Data que es parte de la solución del Sitio Web Mercados Pecuarios.
+
+## Environment Variables

package/build/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./lib/actions";
+export * from "./lib/influxdb_client";
+export * from "./lib/models";

package/build/index.js

@@ -0,0 +1,19 @@
+"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("./lib/actions"), exports);
+__exportStar(require("./lib/influxdb_client"), exports);
+__exportStar(require("./lib/models"), exports);

package/build/lib/actions/actions.d.ts

@@ -0,0 +1,67 @@
+import { AfterQueryRequest } from "./after/after_action";
+import { BeforeQueryRequest } from "./before/before_action";
+/**
+ * Información respecto a una determinada acción a ejecutar para el procesamiento de los puntos.
+ */
+export interface ActionAbstract {
+    /**
+     * @type {string} Nombre que hace referencia a un Link que ejecuta una determinada acción.
+     */
+    name: string;
+    /**
+     * @type {string} Descripción de la acción, es meramente informativa y puede ser escrita en la consola.
+     */
+    description?: string;
+    /**
+     * @type {any} Parámetros son un objeto que contiene la información que el Link requiere en su constructor.
+     */
+    params?: any;
+}
+/**
+ * Información de una acción a ejecutar en el proceso Before (antes de la consulta de los puntos).
+ */
+export interface BeforeAction extends ActionAbstract {
+}
+/**
+ * Información de la acción a ejecutar en el proceso After (después de la consulta de los puntos).
+ */
+export interface AfterAction extends ActionAbstract {
+}
+export declare function getActionsController(): ActionsController;
+export declare class ActionsController {
+    /**
+     * Este método ejecuta el proceso de "Before" antes de la consulta a la base de datos.
+     * Retorna una Promesa con la información recopilada a través de la ejecución de la lista de pasos que recibe como parámetro.
+     * @param request instancia de la petición para el proceso "Before"
+     * @param steps arreglo con la lista de las acciones a ejecutar durante el proceso de "Before" el cual ocurre
+     * antes de ejecutar la consulta a la base de datos.
+     */
+    before(request: BeforeQueryRequest, steps?: Array<BeforeAction>): Promise<BeforeQueryRequest>;
+    /**
+     * Este método ejecuta el proceso de "After" después de la consulta a la base de datos.
+     * Retorna una Promesa con la información recopilada a través de la ejecución de la lista de pasos que recibe como parámetro.
+     * @param request instancia de la petición para el proceso "After"
+     * @param steps arreglo con la lista de acciones a ejecutar durante el proceso de "After" el cual ocurre después
+     * de ejecutar la consulta a la base de datos.
+     */
+    after(request: AfterQueryRequest, steps?: Array<AfterAction>): Promise<AfterQueryRequest>;
+    /**
+     * Método para generar la secuencia de los pasos (cadena de responsabilidades) a ejecutar en un determinado proceso.
+     * La cadena de responsabilidades generada está conformada por un conjunto de eslabones (métodos) que se ejecutan de manera secuencial,
+     * cada método recibe una petición como parámetro, realizar el procesamiento correspondiente y pasa la petición y responabilidad al
+     * siguiente eslabón (método) de la cadena, así hasta haber pasado por todos los eslabones.
+     * @param factory objeto que permite generar la instancia de Link de la cadena de responsabilidades
+     * @param steps arreglo con la lista de pasos (Links) a enlazar en la cadena de responsabilidades.
+     */
+    private getChain;
+    /**
+     * Método para generar la secuencia de los pasos (cadena de responsabilidades) a ejecutar en el proceso Before
+     * @param steps arreglo con la lista de pasos (Links) a enlazar en la cadena de responsabilidades.
+     */
+    private getBeforeChain;
+    /**
+     * Método para generar la secuencia de los pasos (cadena de responabilidades) a ejecutar en el proceso After
+     * @param steps arreglo con la lista de pasos (Links) a enlazar en la cadena de responsabilidades.
+     */
+    private getAfterChain;
+}

package/build/lib/actions/actions.js

@@ -0,0 +1,89 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionsController = exports.getActionsController = void 0;
+const after_action_1 = require("./after/after_action");
+const before_action_1 = require("./before/before_action");
+let actionsController;
+function getActionsController() {
+    if (actionsController === undefined) {
+        actionsController = new ActionsController();
+    }
+    return actionsController;
+}
+exports.getActionsController = getActionsController;
+class ActionsController {
+    /**
+     * Este método ejecuta el proceso de "Before" antes de la consulta a la base de datos.
+     * Retorna una Promesa con la información recopilada a través de la ejecución de la lista de pasos que recibe como parámetro.
+     * @param request instancia de la petición para el proceso "Before"
+     * @param steps arreglo con la lista de las acciones a ejecutar durante el proceso de "Before" el cual ocurre
+     * antes de ejecutar la consulta a la base de datos.
+     */
+    before(request, steps) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const chain = this.getBeforeChain(steps);
+            yield chain.process(request);
+            return request;
+        });
+    }
+    /**
+     * Este método ejecuta el proceso de "After" después de la consulta a la base de datos.
+     * Retorna una Promesa con la información recopilada a través de la ejecución de la lista de pasos que recibe como parámetro.
+     * @param request instancia de la petición para el proceso "After"
+     * @param steps arreglo con la lista de acciones a ejecutar durante el proceso de "After" el cual ocurre después
+     * de ejecutar la consulta a la base de datos.
+     */
+    after(request, steps) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const chain = this.getAfterChain(steps);
+            yield chain.process(request);
+            return request;
+        });
+    }
+    /**
+     * Método para generar la secuencia de los pasos (cadena de responsabilidades) a ejecutar en un determinado proceso.
+     * La cadena de responsabilidades generada está conformada por un conjunto de eslabones (métodos) que se ejecutan de manera secuencial,
+     * cada método recibe una petición como parámetro, realizar el procesamiento correspondiente y pasa la petición y responabilidad al
+     * siguiente eslabón (método) de la cadena, así hasta haber pasado por todos los eslabones.
+     * @param factory objeto que permite generar la instancia de Link de la cadena de responsabilidades
+     * @param steps arreglo con la lista de pasos (Links) a enlazar en la cadena de responsabilidades.
+     */
+    getChain(factory, steps) {
+        if (steps && steps.length > 0) {
+            const chain = factory.create(steps[0]);
+            let last = chain;
+            for (let i = 1; i < steps.length; i++) {
+                const link = factory.create(steps[i]);
+                last = last.link(link);
+            }
+            return chain;
+        }
+        return factory.empty();
+    }
+    /**
+     * Método para generar la secuencia de los pasos (cadena de responsabilidades) a ejecutar en el proceso Before
+     * @param steps arreglo con la lista de pasos (Links) a enlazar en la cadena de responsabilidades.
+     */
+    getBeforeChain(steps) {
+        const factory = before_action_1.BeforeChainLinkFactory.getInstance();
+        return this.getChain(factory, steps);
+    }
+    /**
+     * Método para generar la secuencia de los pasos (cadena de responabilidades) a ejecutar en el proceso After
+     * @param steps arreglo con la lista de pasos (Links) a enlazar en la cadena de responsabilidades.
+     */
+    getAfterChain(steps) {
+        const factory = after_action_1.AfterChainLinkFactory.getInstance();
+        return this.getChain(factory, steps);
+    }
+}
+exports.ActionsController = ActionsController;

package/build/lib/actions/after/add_values.d.ts

@@ -0,0 +1,9 @@
+import { ChainLinkAbstract } from "../chain";
+import { AfterChainLink, AfterQueryRequest } from "./after_action";
+export declare class AddValuesAfterAction extends ChainLinkAbstract<AfterQueryRequest> implements AfterChainLink {
+    private _tagKey;
+    constructor(params: {
+        tagKey: string;
+    });
+    run(req: AfterQueryRequest): Promise<void>;
+}

package/build/lib/actions/after/add_values.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddValuesAfterAction = void 0;
+const chain_1 = require("../chain");
+class AddValuesAfterAction extends chain_1.ChainLinkAbstract {
+    constructor(params) {
+        super();
+        this._tagKey = params.tagKey;
+    }
+    run(req) {
+        console.debug(`Processing action ${this.constructor.name}`);
+        const tags = req.getPointsQuery.tags;
+        const { periodicity } = tags;
+        const key = this._tagKey;
+        const groupedPoints = {};
+        if (key && key != "") {
+            for (const point of req.points) {
+                const time = point._time;
+                const year = point.year;
+                const month = point.month;
+                const tag = Array.isArray(tags[key]) ? tags[key].join(',') : tags[key];
+                const id = `${time}_${tag}`;
+                if (!groupedPoints[id]) {
+                    groupedPoints[id] = { _time: time, year: year || new Date(time).getUTCFullYear(), _value: 0, [key]: [] };
+                }
+                if (periodicity === "Monthly" && month) {
+                    groupedPoints[id].month = month;
+                }
+                groupedPoints[id]._value += point._value;
+                if (!groupedPoints[id][key].includes(point[key])) {
+                    groupedPoints[id][key].push(point[key]);
+                }
+            }
+            req.points = Object.values(groupedPoints);
+        }
+        return;
+    }
+}
+exports.AddValuesAfterAction = AddValuesAfterAction;

package/build/lib/actions/after/after_action.d.ts

@@ -0,0 +1,35 @@
+import { GetPointsQuery } from "../../models";
+import { AfterAction } from "../actions";
+import { BaseChainLinkFactory } from "../base_chain_factory";
+import { ChainLink } from "../chain";
+/**
+ * Representación de una solicitud para la cadena de responsabilidades
+ * que se ejecuta después de la consulta a la base de datos.
+ */
+export interface AfterQueryRequest {
+    getPointsQuery: GetPointsQuery;
+    points: any[];
+}
+/**
+ * Representa un eslabón de una cadena responsabilidades
+ * que se ejecuta después de la consulta a la base de datos.
+ * Recibe una solicitud del tipo "AfterQueryRequest".
+ */
+export interface AfterChainLink extends ChainLink<AfterQueryRequest> {
+}
+/**
+ * Implementación del Factory para los eslabones de la cadena de responsabilidades
+ * que se ejecuta después de la consulta de la base de datos.
+ */
+export declare class AfterChainLinkFactory extends BaseChainLinkFactory<AfterAction, AfterChainLink> {
+    private constructor();
+    /**
+     * Permite obtener la instancia única del Factory
+     */
+    static getInstance(): AfterChainLinkFactory;
+    /**
+     * Genera una instancia del eslabón vacío para la cadena de
+     * responsabilidades que se ejecuta después de la prueba
+     */
+    empty(): AfterChainLink;
+}

package/build/lib/actions/after/after_action.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AfterChainLinkFactory = void 0;
+const base_chain_factory_1 = require("../base_chain_factory");
+const null_action_1 = require("./null_action");
+/**
+ * Ruta del archivo que contiene la lista de eslabones conocidos para
+ * la cadena de responsabilidades que se ejecuta después de la consulta a la base de datos.
+ */
+const AFTER_LINK_PATH = "../after-actions.json";
+/**
+ * Instancia única de la Factory para eslabones de la cadena de responsabilidades
+ * que se ejecuta después de la consulta de la base de datos
+ */
+let afterChainLinkFactory = null;
+/**
+ * Implementación del Factory para los eslabones de la cadena de responsabilidades
+ * que se ejecuta después de la consulta de la base de datos.
+ */
+class AfterChainLinkFactory extends base_chain_factory_1.BaseChainLinkFactory {
+    constructor() {
+        super(AFTER_LINK_PATH);
+    }
+    /**
+     * Permite obtener la instancia única del Factory
+     */
+    static getInstance() {
+        if (afterChainLinkFactory === null) {
+            afterChainLinkFactory = new AfterChainLinkFactory();
+        }
+        return afterChainLinkFactory;
+    }
+    /**
+     * Genera una instancia del eslabón vacío para la cadena de
+     * responsabilidades que se ejecuta después de la prueba
+     */
+    empty() {
+        return new null_action_1.NullAfterAction();
+    }
+}
+exports.AfterChainLinkFactory = AfterChainLinkFactory;

package/build/lib/actions/after/average.d.ts

@@ -0,0 +1,15 @@
+import { ChainLinkAbstract } from "../chain";
+import { AfterChainLink, AfterQueryRequest } from "./after_action";
+export declare class AverageAfterAction extends ChainLinkAbstract<AfterQueryRequest> implements AfterChainLink {
+    private groupColumn;
+    private years;
+    private timeColumn;
+    private valueColumn;
+    constructor(params: {
+        groupColumn: string;
+        years: number[];
+        timeColumn?: string;
+        valueColumn?: string;
+    });
+    run(req: AfterQueryRequest): Promise<void>;
+}

package/build/lib/actions/after/average.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AverageAfterAction = void 0;
+const chain_1 = require("../chain");
+class AverageAfterAction extends chain_1.ChainLinkAbstract {
+    constructor(params) {
+        super();
+        this.timeColumn = "_time";
+        this.valueColumn = "_value";
+        this.groupColumn = params.groupColumn;
+        this.years = params.years;
+        if (params.timeColumn) {
+            this.timeColumn = params.timeColumn;
+        }
+        if (params.valueColumn) {
+            this.valueColumn = params.valueColumn;
+        }
+    }
+    run(req) {
+        console.debug(`Processing action ${this.constructor.name}`);
+        const groupedPoints = {};
+        const k = this.groupColumn;
+        const t = this.timeColumn;
+        const v = this.valueColumn;
+        const isAnnual = req.getPointsQuery.tags["periodicity"] === "Annual" || req.getPointsQuery.tags["periodicity"] === "Agricultural Commercial Cycle";
+        if (req.points && Array.isArray(req.points) && req.points.length) {
+            req.points.forEach((point) => {
+                if (point[k] && point[t]) {
+                    try {
+                        const key = point[k];
+                        if (!groupedPoints[key]) {
+                            groupedPoints[key] = { years: [], values: [] };
+                        }
+                        const date = new Date(point[t]);
+                        const year = date.getUTCFullYear();
+                        if (this.years.includes(year)) {
+                            if (point[v]) {
+                                const group = groupedPoints[key];
+                                group.values.push(point[v]);
+                                if (!group.years.includes(year)) {
+                                    group.years.push(year);
+                                }
+                            }
+                        }
+                    }
+                    catch (reason) { }
+                }
+            });
+            var _sum = 0;
+            var _years = [];
+            for (const key in groupedPoints) {
+                const group = groupedPoints[key];
+                if (group.values.length === 1) {
+                    if (!_years.includes(parseInt(key))) {
+                        _years.push(parseInt(key));
+                    }
+                    _sum += group.values[0];
+                }
+                const sum = group.values.reduce((a, b) => a + b, 0);
+                const avg = sum / group.values.length;
+                const point = {
+                    isAverage: true,
+                    years: group.years,
+                    _value: avg,
+                };
+                if (!isAnnual) {
+                    point[k] = key;
+                    req.points.push(point);
+                }
+            }
+            if (isAnnual) {
+                const point = {
+                    isAverage: true,
+                    years: _years,
+                    _value: _sum / _years.length,
+                };
+                req.points.push(point);
+            }
+        }
+        return;
+    }
+}
+exports.AverageAfterAction = AverageAfterAction;

package/build/lib/actions/after/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./add_values";
+export * from "./after_action";
+export * from "./average";
+export * from "./null_action";
+export * from "./omit_years";
+export * from "./only_average";
+export * from "./parse_int_columns";
+export * from "./print_points";
+export * from "./set_month_index";
+export * from "./sort";

package/build/lib/actions/after/index.js

@@ -0,0 +1,26 @@
+"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("./add_values"), exports);
+__exportStar(require("./after_action"), exports);
+__exportStar(require("./average"), exports);
+__exportStar(require("./null_action"), exports);
+__exportStar(require("./omit_years"), exports);
+__exportStar(require("./only_average"), exports);
+__exportStar(require("./parse_int_columns"), exports);
+__exportStar(require("./print_points"), exports);
+__exportStar(require("./set_month_index"), exports);
+__exportStar(require("./sort"), exports);

package/build/lib/actions/after/null_action.d.ts

@@ -0,0 +1,6 @@
+import { ChainLinkAbstract } from "../chain";
+import { AfterChainLink, AfterQueryRequest } from "./after_action";
+export declare class NullAfterAction extends ChainLinkAbstract<AfterQueryRequest> implements AfterChainLink {
+    constructor();
+    run(req: AfterQueryRequest): Promise<void>;
+}

package/build/lib/actions/after/null_action.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullAfterAction = void 0;
+const chain_1 = require("../chain");
+class NullAfterAction extends chain_1.ChainLinkAbstract {
+    constructor() {
+        super();
+    }
+    run(req) {
+        console.debug(`Processing action ${this.constructor.name}`);
+        return;
+    }
+}
+exports.NullAfterAction = NullAfterAction;

package/build/lib/actions/after/omit_years.d.ts

@@ -0,0 +1,11 @@
+import { ChainLinkAbstract } from "../chain";
+import { AfterChainLink, AfterQueryRequest } from "./after_action";
+export declare class OmitYearsAfterAction extends ChainLinkAbstract<AfterQueryRequest> implements AfterChainLink {
+    private years;
+    private timeColumn;
+    constructor(params: {
+        years: number[];
+        timeColumn?: string;
+    });
+    run(req: AfterQueryRequest): Promise<void>;
+}

package/build/lib/actions/after/omit_years.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmitYearsAfterAction = void 0;
+const chain_1 = require("../chain");
+class OmitYearsAfterAction extends chain_1.ChainLinkAbstract {
+    constructor(params) {
+        var _a;
+        super();
+        this.timeColumn = "_time";
+        this.years = params.years;
+        this.timeColumn = (_a = params.timeColumn) !== null && _a !== void 0 ? _a : this.timeColumn;
+    }
+    run(req) {
+        console.debug(`Processing action ${this.constructor.name}`);
+        if (req.points && Array.isArray(req.points)) {
+            req.points = req.points.filter(point => {
+                if (point.year) {
+                    return !this.years.includes(point.year);
+                }
+                const timeKey = this.timeColumn;
+                const date = new Date(point[timeKey]);
+                const year = date.getUTCFullYear();
+                return !this.years.includes(year);
+            });
+        }
+        return;
+    }
+}
+exports.OmitYearsAfterAction = OmitYearsAfterAction;

package/build/lib/actions/after/only_average.d.ts

@@ -0,0 +1,6 @@
+import { ChainLinkAbstract } from "../chain";
+import { AfterChainLink, AfterQueryRequest } from "./after_action";
+export declare class OnlyAverageAfterAction extends ChainLinkAbstract<AfterQueryRequest> implements AfterChainLink {
+    constructor();
+    run(req: AfterQueryRequest): Promise<void>;
+}

package/build/lib/actions/after/only_average.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnlyAverageAfterAction = void 0;
+const chain_1 = require("../chain");
+class OnlyAverageAfterAction extends chain_1.ChainLinkAbstract {
+    constructor() {
+        super();
+    }
+    run(req) {
+        console.debug(`Processing action ${this.constructor.name}`);
+        if (req.points && Array.isArray(req.points)) {
+            req.points = req.points.filter(p => p.isAverage);
+        }
+        return;
+    }
+}
+exports.OnlyAverageAfterAction = OnlyAverageAfterAction;

package/build/lib/actions/after/parse_int_columns.d.ts

@@ -0,0 +1,9 @@
+import { ChainLinkAbstract } from "../chain";
+import { AfterChainLink, AfterQueryRequest } from "./after_action";
+export declare class ParseIntColumnsAfterAction extends ChainLinkAbstract<AfterQueryRequest> implements AfterChainLink {
+    private columns;
+    constructor(params: {
+        columns: string | string[];
+    });
+    run(req: AfterQueryRequest): Promise<void>;
+}

package/build/lib/actions/after/parse_int_columns.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseIntColumnsAfterAction = void 0;
+const chain_1 = require("../chain");
+class ParseIntColumnsAfterAction extends chain_1.ChainLinkAbstract {
+    constructor(params) {
+        super();
+        if (Array.isArray(params.columns)) {
+            this.columns = params.columns;
+        }
+        else {
+            this.columns = params.columns.split(",");
+        }
+    }
+    run(req) {
+        console.debug(`Processing action ${this.constructor.name}`);
+        if (req.points && Array.isArray(req.points)) {
+            req.points.forEach((point) => {
+                this.columns.forEach((k) => {
+                    if (point[k]) {
+                        if (typeof point[k] === "string") {
+                            try {
+                                const n = parseInt(point[k], 10);
+                                point[k] = n;
+                            }
+                            catch (error) { }
+                        }
+                    }
+                });
+            });
+        }
+        return;
+    }
+}
+exports.ParseIntColumnsAfterAction = ParseIntColumnsAfterAction;

package/build/lib/actions/after/print_points.d.ts

@@ -0,0 +1,6 @@
+import { ChainLinkAbstract } from "../chain";
+import { AfterChainLink, AfterQueryRequest } from "./after_action";
+export declare class PrintPointsAfterAction extends ChainLinkAbstract<AfterQueryRequest> implements AfterChainLink {
+    constructor();
+    run(req: AfterQueryRequest): Promise<void>;
+}

package/build/lib/actions/after/print_points.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrintPointsAfterAction = void 0;
+const chain_1 = require("../chain");
+class PrintPointsAfterAction extends chain_1.ChainLinkAbstract {
+    constructor() {
+        super();
+    }
+    run(req) {
+        if (req.points && Array.isArray(req.points)) {
+            req.points.forEach((point) => console.log(point));
+        }
+        return;
+    }
+}
+exports.PrintPointsAfterAction = PrintPointsAfterAction;

package/build/lib/actions/after/set_month_index.d.ts

@@ -0,0 +1,9 @@
+import { ChainLinkAbstract } from "../chain";
+import { AfterChainLink, AfterQueryRequest } from "./after_action";
+export declare class SetMonthIndexAfterAction extends ChainLinkAbstract<AfterQueryRequest> implements AfterChainLink {
+    private column;
+    constructor(params?: {
+        column?: string;
+    });
+    run(req: AfterQueryRequest): Promise<void>;
+}