@eyeseetea/d2-logger 0.1.0-beta.1

package/README.md

@@ -0,0 +1,96 @@
+# d2-logger
+
+DHIS2 library that allows a certain application to register logs as events in a DHIS2 program or display logs on the console.
+
+## Usage
+
+There are two types of logger output:
+
+1. Using a DHIS2 events program to register the logs:
+
+    You will need to have and existing event program in DHIS2 with the following data elements with value type Text: Message and MessageType. MessageType would be and option set with the following options: "Error", "Warn", "Success", "Info" and "Debug".
+
+    Therefore, the following configuration will be passed to the logger:
+
+    ```typescript
+    import { Logger } from "@eyeseetea/d2-logger";
+
+    const logger = new Logger();
+
+    await logger.init({
+        type: "program",
+        debug: debug,
+        baseUrl: baseUrl,
+        auth: auth,
+        organisationUnitId: organisationUnitId,
+        programId: programId,
+        loggerDataElements: {
+            messageId: messageId,
+            messageTypeId: messageTypeId,
+        },
+    });
+
+    logger.debug("This is a Debug message");
+    logger.info("This is an Info message");
+    logger.success("This is a Success message");
+    logger.warn("This is a Warn message");
+    logger.error("This is an Error message");
+    ```
+
+    Notice:
+
+    - Please note that `auth` is not mandatory if it's used in the DHIS2 app instead of in a script.
+    - Please note that if the `organisationUnitId` is not added to the configuration, then the logs will be registered in the DHIS2 program in the global organization unit.
+    - If `debug` is `true`, then in addition to registering the logs in the DHIS2 program, they will also be displayed on the console.
+
+2. Displaying the logs only in the console:
+
+    ```typescript
+    import { Logger } from "@eyeseetea/d2-logger";
+
+    const logger = new Logger();
+
+    logger.init({
+        type: "console",
+    });
+
+    logger.debug("This is a Debug message");
+    logger.info("This is an Info message");
+    logger.success("This is a Success message");
+    logger.warn("This is a Warn message");
+    logger.error("This is an Error message");
+    ```
+
+## Development
+
+```bash
+$ yarn install
+$ yarn build
+$ cd build
+$ yarn link
+```
+
+On another app:
+
+```bash
+$ yarn link "@eyeseetea/d2-logger"
+```
+
+## Tests
+
+```bash
+$ yarn test
+```
+
+## Code quality
+
+```bash
+$ yarn code-quality
+```
+
+## Publish
+
+```bash
+$ yarn prerelease
+$ yarn release [--tag beta] [--patch | --minor | --major]
+```

package/data/api-futures.d.ts

@@ -0,0 +1,4 @@
+import { Future } from "../domain/entities/generic/Future";
+import { CancelableResponse } from "../types/d2-api";
+export type FutureData<D> = Future<Error, D>;
+export declare function apiToFuture<Data>(res: CancelableResponse<Data>): FutureData<Data>;

package/data/api-futures.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiToFuture = void 0;
+var Future_1 = require("../domain/entities/generic/Future");
+function apiToFuture(res) {
+    return Future_1.Future.fromComputation(function (resolve, reject) {
+        res.getData()
+            .then(resolve)
+            .catch(function (err) {
+            if (err instanceof Error) {
+                reject(err);
+            }
+            else {
+                console.error("apiToFuture:uncatched", err);
+                reject(new Error("Unknown error"));
+            }
+        });
+        return res.cancel;
+    });
+}
+exports.apiToFuture = apiToFuture;

package/data/repositories/ConsoleLoggerRepository.d.ts

@@ -0,0 +1,6 @@
+import { FutureData } from "../../data/api-futures";
+import { Log } from "../../domain/entities/Log";
+import { LoggerRepository } from "../../domain/repositories/LoggerRepository";
+export declare class ConsoleLoggerRepository implements LoggerRepository {
+    log(log: Log): FutureData<void>;
+}

package/data/repositories/ConsoleLoggerRepository.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLoggerRepository = void 0;
+var Future_1 = require("../../domain/entities/generic/Future");
+var ConsoleLoggerRepository = /** @class */ (function () {
+    function ConsoleLoggerRepository() {
+    }
+    ConsoleLoggerRepository.prototype.log = function (log) {
+        var message = log.message, messageType = log.messageType;
+        var date = new Date().toISOString();
+        process.stderr.write("[".concat(messageType.toUpperCase(), "] [").concat(date, "] ").concat(message, "\n"));
+        return Future_1.Future.success(undefined);
+    };
+    return ConsoleLoggerRepository;
+}());
+exports.ConsoleLoggerRepository = ConsoleLoggerRepository;

package/data/repositories/ProgramD2Repository.d.ts

@@ -0,0 +1,7 @@
+import { FutureData } from "../../data/api-futures";
+import { ProgramLoggerConfig } from "../../domain/entities/LoggerConfig";
+import { ProgramRepository } from "../../domain/repositories/ProgramRepository";
+export declare class ProgramD2Repository implements ProgramRepository {
+    checkConfig(config: ProgramLoggerConfig): FutureData<boolean>;
+    private checkProgramIsOk;
+}

package/data/repositories/ProgramD2Repository.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgramD2Repository = void 0;
+var d2_api_1 = require("../../types/d2-api");
+var api_futures_1 = require("../../data/api-futures");
+var Future_1 = require("../../domain/entities/generic/Future");
+var ProgramD2Repository = /** @class */ (function () {
+    function ProgramD2Repository() {
+    }
+    ProgramD2Repository.prototype.checkConfig = function (config) {
+        var baseUrl = config.baseUrl, auth = config.auth, programId = config.programId, loggerDataElements = config.loggerDataElements;
+        var d2Api = auth
+            ? new d2_api_1.D2Api({ baseUrl: baseUrl, auth: auth })
+            : new d2_api_1.D2Api({ baseUrl: baseUrl });
+        return this.checkProgramIsOk(d2Api, programId, loggerDataElements).flatMap(function (programIsOk) {
+            if (programIsOk) {
+                return Future_1.Future.success(programIsOk);
+            }
+            else {
+                return Future_1.Future.error(new Error("Logger not initialized properly. Please check configuration of program ".concat(programId, ", message data element ").concat(loggerDataElements.messageId, " and message type data element ").concat(loggerDataElements.messageTypeId, ".")));
+            }
+        });
+    };
+    ProgramD2Repository.prototype.checkProgramIsOk = function (api, programId, loggerDataElements) {
+        return (0, api_futures_1.apiToFuture)(api.models.programs.get({
+            fields: programFields,
+            filter: { id: { eq: programId } },
+        })).flatMap(function (response) {
+            var _a, _b, _c, _d;
+            if ((_a = response === null || response === void 0 ? void 0 : response.objects[0]) === null || _a === void 0 ? void 0 : _a.programStages[0]) {
+                var programStageDataElements = response.objects[0].programStages[0].programStageDataElements;
+                var messageDataElement = (_b = programStageDataElements.find(function (_a) {
+                    var dataElement = _a.dataElement;
+                    return dataElement.id === (loggerDataElements === null || loggerDataElements === void 0 ? void 0 : loggerDataElements.messageId);
+                })) === null || _b === void 0 ? void 0 : _b.dataElement;
+                var messageTypeDataElement = (_c = programStageDataElements.find(function (_a) {
+                    var dataElement = _a.dataElement;
+                    return dataElement.id === (loggerDataElements === null || loggerDataElements === void 0 ? void 0 : loggerDataElements.messageTypeId);
+                })) === null || _c === void 0 ? void 0 : _c.dataElement;
+                var isMessageDataElementOk = (messageDataElement === null || messageDataElement === void 0 ? void 0 : messageDataElement.valueType) === "TEXT" ||
+                    (messageDataElement === null || messageDataElement === void 0 ? void 0 : messageDataElement.valueType) === "LONG_TEXT";
+                var isMessageTypeDataElementOk = !!(messageTypeDataElement === null || messageTypeDataElement === void 0 ? void 0 : messageTypeDataElement.optionSetValue);
+                return Future_1.Future.success(((_d = response.objects[0]) === null || _d === void 0 ? void 0 : _d.id) === programId &&
+                    isMessageDataElementOk &&
+                    isMessageTypeDataElementOk);
+            }
+            else {
+                return Future_1.Future.error(new Error("Program with id ".concat(programId, " and its program stage not found. Logger not initialized")));
+            }
+        });
+    };
+    return ProgramD2Repository;
+}());
+exports.ProgramD2Repository = ProgramD2Repository;
+var programFields = {
+    id: true,
+    programStages: {
+        id: true,
+        programStageDataElements: {
+            dataElement: {
+                id: true,
+                code: true,
+                valueType: true,
+                optionSetValue: true,
+                optionSet: { options: { name: true, code: true } },
+            },
+        },
+    },
+};

package/data/repositories/ProgramLoggerD2Repository.d.ts

@@ -0,0 +1,19 @@
+import { D2Api } from "../../types/d2-api";
+import { FutureData } from "../api-futures";
+import { Id } from "../../domain/entities/Base";
+import { Log } from "../../domain/entities/Log";
+import { ProgramLoggerConfig } from "../../domain/entities/LoggerConfig";
+import { LoggerRepository } from "../../domain/repositories/LoggerRepository";
+export declare class ProgramLoggerD2Repository implements LoggerRepository {
+    api: D2Api;
+    organisationUnitId: Id;
+    programId: Id;
+    messageId: Id;
+    messageTypeId: Id;
+    constructor(config: ProgramLoggerConfig);
+    log(log: Log): FutureData<void>;
+    private getProgramStage;
+    private postApiTracker;
+    private mapLogToD2EventProgam;
+    private getDataValuesFromLog;
+}

package/data/repositories/ProgramLoggerD2Repository.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgramLoggerD2Repository = void 0;
+var d2_api_1 = require("../../types/d2-api");
+var api_futures_1 = require("../api-futures");
+var Future_1 = require("../../domain/entities/generic/Future");
+var GLOBAL_ORGANISATION_UNIT_ID = "H8RixfF8ugH";
+var IMPORT_STRATEGY_CREATE = "CREATE";
+var TRACKER_IMPORT_JOB = "TRACKER_IMPORT_JOB";
+var EVENT_PROGRAM_STATUS = "COMPLETED";
+var ProgramLoggerD2Repository = /** @class */ (function () {
+    function ProgramLoggerD2Repository(config) {
+        var baseUrl = config.baseUrl, auth = config.auth, programId = config.programId, loggerDataElements = config.loggerDataElements, _a = config.organisationUnitId, organisationUnitId = _a === void 0 ? GLOBAL_ORGANISATION_UNIT_ID : _a;
+        this.api = auth
+            ? new d2_api_1.D2Api({ baseUrl: baseUrl, auth: auth })
+            : new d2_api_1.D2Api({ baseUrl: baseUrl });
+        this.programId = programId;
+        this.messageId = loggerDataElements.messageId;
+        this.messageTypeId = loggerDataElements.messageTypeId;
+        this.organisationUnitId = organisationUnitId;
+    }
+    ProgramLoggerD2Repository.prototype.log = function (log) {
+        var _this = this;
+        return this.getProgramStage().flatMap(function (programStage) {
+            var d2EventProgram = _this.mapLogToD2EventProgam({
+                log: log,
+                programId: _this.programId,
+                organisationUnitId: _this.organisationUnitId,
+                messageId: _this.messageId,
+                messageTypeId: _this.messageTypeId,
+                programStage: programStage,
+            });
+            return _this.postApiTracker(d2EventProgram);
+        });
+    };
+    ProgramLoggerD2Repository.prototype.getProgramStage = function () {
+        var _this = this;
+        return (0, api_futures_1.apiToFuture)(this.api.models.programs.get({
+            fields: programFields,
+            filter: { id: { eq: this.programId } },
+        })).flatMap(function (response) {
+            var _a, _b;
+            if ((_a = response.objects[0]) === null || _a === void 0 ? void 0 : _a.programStages[0]) {
+                return Future_1.Future.success((_b = response.objects[0]) === null || _b === void 0 ? void 0 : _b.programStages[0]);
+            }
+            else {
+                return Future_1.Future.error(new Error("Program stage of program with id ".concat(_this.programId, " not found")));
+            }
+        });
+    };
+    ProgramLoggerD2Repository.prototype.postApiTracker = function (d2EventProgram) {
+        var _this = this;
+        return (0, api_futures_1.apiToFuture)(this.api.tracker.postAsync({
+            importStrategy: IMPORT_STRATEGY_CREATE,
+            skipRuleEngine: true,
+        }, { events: [d2EventProgram] })).flatMap(function (response) {
+            return (0, api_futures_1.apiToFuture)(_this.api.system.waitFor(TRACKER_IMPORT_JOB, response.response.id)).flatMap(function (result) {
+                var _a, _b, _c;
+                if (result && result.status !== "ERROR") {
+                    return Future_1.Future.success(undefined);
+                }
+                else {
+                    return Future_1.Future.error(new Error("Error: ".concat((_c = (_b = (_a = result === null || result === void 0 ? void 0 : result.validationReport) === null || _a === void 0 ? void 0 : _a.errorReports) === null || _b === void 0 ? void 0 : _b.at(0)) === null || _c === void 0 ? void 0 : _c.message, " ")));
+                }
+            });
+        });
+    };
+    ProgramLoggerD2Repository.prototype.mapLogToD2EventProgam = function (params) {
+        var log = params.log, programId = params.programId, messageId = params.messageId, messageTypeId = params.messageTypeId, organisationUnitId = params.organisationUnitId, programStage = params.programStage;
+        var dataValues = this.getDataValuesFromLog({
+            log: log,
+            messageId: messageId,
+            messageTypeId: messageTypeId,
+            programStage: programStage,
+        });
+        return {
+            event: "",
+            occurredAt: new Date().toISOString(),
+            status: EVENT_PROGRAM_STATUS,
+            program: programId,
+            programStage: programStage.id,
+            orgUnit: organisationUnitId,
+            dataValues: dataValues,
+        };
+    };
+    ProgramLoggerD2Repository.prototype.getDataValuesFromLog = function (params) {
+        var _a, _b;
+        var log = params.log, messageId = params.messageId, messageTypeId = params.messageTypeId, programStage = params.programStage;
+        var messageTypeDataElement = (_a = programStage.programStageDataElements.find(function (_a) {
+            var dataElement = _a.dataElement;
+            return dataElement.id === messageTypeId;
+        })) === null || _a === void 0 ? void 0 : _a.dataElement;
+        var messageTypeDataValue = ((_b = messageTypeDataElement === null || messageTypeDataElement === void 0 ? void 0 : messageTypeDataElement.optionSet.options.find(function (option) { return option.name === log.messageType || option.code === log.messageType; })) === null || _b === void 0 ? void 0 : _b.code) || log.messageType;
+        return [
+            {
+                dataElement: messageId,
+                value: log.message,
+            },
+            {
+                dataElement: messageTypeId,
+                value: messageTypeDataValue,
+            },
+        ];
+    };
+    return ProgramLoggerD2Repository;
+}());
+exports.ProgramLoggerD2Repository = ProgramLoggerD2Repository;
+var programFields = {
+    id: true,
+    programStages: {
+        id: true,
+        programStageDataElements: {
+            dataElement: {
+                id: true,
+                code: true,
+                valueType: true,
+                optionSetValue: true,
+                optionSet: { options: { name: true, code: true } },
+            },
+        },
+    },
+};

package/domain/entities/Async.d.ts

@@ -0,0 +1 @@
+export type Async<Data> = Promise<Data>;

package/domain/entities/Async.js

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

package/domain/entities/Base.d.ts

@@ -0,0 +1,17 @@
+import { HashMap } from "./generic/HashMap";
+export type Id = string;
+export type Ref = {
+    id: Id;
+};
+export type NamedRef = {
+    id: Id;
+    name: string;
+};
+export type Path = string;
+export type Username = string;
+export type IndexedById<T> = Record<Id, T>;
+export declare function getId<Obj extends Ref>(obj: Obj): Id;
+export declare function indexById<T extends Ref>(objs: T[]): HashMap<Id, T>;
+export type Code = string;
+export type Name = string;
+export type Identifiable = Id | Code | Name;

package/domain/entities/Base.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexById = exports.getId = void 0;
+var Collection_1 = __importDefault(require("./generic/Collection"));
+function getId(obj) {
+    return obj.id;
+}
+exports.getId = getId;
+function indexById(objs) {
+    return (0, Collection_1.default)(objs).keyBy(getId);
+}
+exports.indexById = indexById;

package/domain/entities/Log.d.ts

@@ -0,0 +1,5 @@
+export type Log = {
+    message: string;
+    messageType: MessageType;
+};
+export type MessageType = "Debug" | "Info" | "Success" | "Warn" | "Error";

package/domain/entities/Log.js

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

package/domain/entities/LoggerConfig.d.ts

@@ -0,0 +1,25 @@
+import { Id } from "./Base";
+interface LoggerConfigBase {
+    debug?: boolean;
+}
+export type LoggerConfig = ProgramLoggerConfig | ConsoleLoggerConfig;
+export interface ConsoleLoggerConfig extends LoggerConfigBase {
+    type: "console";
+}
+export interface ProgramLoggerConfig extends LoggerConfigBase {
+    type: "program";
+    baseUrl: string;
+    auth?: Auth;
+    programId: Id;
+    loggerDataElements: LoggerDataElements;
+    organisationUnitId?: Id;
+}
+type Auth = {
+    username: string;
+    password: string;
+};
+export type LoggerDataElements = {
+    messageId: Id;
+    messageTypeId: Id;
+};
+export {};

package/domain/entities/LoggerConfig.js

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

package/domain/entities/generic/Collection.d.ts

@@ -0,0 +1,82 @@
+import { HashMap } from "./HashMap";
+/**
+ * Wrap a collection of values, expanding methods for Javascript Arrays. An example:
+ *
+ * ```
+ * import _ from "./Collection";
+ *
+ * const values = _(["1", "2", "3", "3", "4"])
+ *     .map(x => parseInt(x))
+ *     .filter(x => x > 1)
+ *     .uniq()
+ *     .reverse()
+ *     .value(); // [4, 3, 2]
+ * ```
+ */
+export declare class Collection<T> {
+    protected xs: T[];
+    protected constructor(values: T[]);
+    static from<T>(xs: T[]): Collection<T>;
+    static range(start: number, end: number, step?: number): Collection<number>;
+    value(): T[];
+    toArray: () => T[];
+    get size(): number;
+    map<U>(fn: (x: T) => U): Collection<U>;
+    flatten(): T extends Array<infer U> ? Collection<U> : never;
+    flatMap<U>(fn: (x: T) => Collection<U>): Collection<U>;
+    select(pred: (x: T) => boolean): Collection<T>;
+    filter: (pred: (x: T) => boolean) => Collection<T>;
+    reject(pred: (x: T) => boolean): Collection<T>;
+    enumerate(): Collection<[number, T]>;
+    compact(): Collection<NonNullable<T>>;
+    compactMap<U>(fn: (x: T) => U | undefined | null): Collection<U>;
+    append(x: T): Collection<T>;
+    includes(x: T): boolean;
+    every(pred: (x: T) => boolean): boolean;
+    all: (pred: (x: T) => boolean) => boolean;
+    some(pred: (x: T) => boolean): boolean;
+    any: (pred: (x: T) => boolean) => boolean;
+    find<Or extends T | undefined>(pred: (x: T) => boolean, options?: {
+        or?: Or;
+    }): T | Or;
+    sort(): Collection<T>;
+    reverse(): Collection<T>;
+    sortWith(compareFn: CompareFn<T>): Collection<T>;
+    sortBy<U>(fn: (x: T) => U, options?: {
+        compareFn?: CompareFn<U>;
+    }): Collection<T>;
+    orderBy(items: OrderItem<T>[]): Collection<T>;
+    first(): T | undefined;
+    last(): T | undefined;
+    sum(): number;
+    take(n: number): Collection<T>;
+    drop(n: number): Collection<T>;
+    pairwise(): Collection<[T, T]>;
+    prepend(x: T): Collection<T>;
+    tap(fn: (xs: Collection<T>) => void): this;
+    splitAt(indexes: number[]): Collection<Collection<T>>;
+    thru<U>(fn: (xs: Collection<T>) => Collection<U>): Collection<U>;
+    join(char: string): string;
+    get(idx: number): T | undefined;
+    getMany(idxs: number[]): Collection<T | undefined>;
+    intersperse(value: T): Collection<T>;
+    uniq(): Collection<T>;
+    uniqBy<U>(mapper: (value: T) => U): Collection<T>;
+    reduce<U>(mapper: (acc: U, value: T) => U, initialAcc: U): U;
+    chunk(size: number): Collection<T[]>;
+    cartesian(): T extends Array<infer U> ? Collection<U[]> : never;
+    zipLongest<S>(xs: Collection<S>): Collection<[T | undefined, S | undefined]>;
+    zip<S>(xs: Collection<S>): Collection<[T, S]>;
+    indexBy<U>(grouperFn: (x: T) => U): HashMap<U, T>;
+    keyBy: <U>(grouperFn: (x: T) => U) => HashMap<U, T>;
+    groupBy<U>(grouperFn: (x: T) => U): HashMap<U, T[]>;
+    groupFromMap<U, W>(pairGrouperFn: (x: T) => [U, W]): HashMap<U, W[]>;
+    toHashMap<K, V>(toPairFn: (x: T) => [K, V]): HashMap<K, V>;
+    isEmpty(): boolean;
+    isNotEmpty(): boolean;
+}
+type CompareRes = -1 | 0 | 1;
+type CompareFn<T> = (a: T, b: T) => CompareRes;
+type OrderItem<T> = [(obj: T) => unknown, "asc" | "desc"];
+export default function _c<T>(xs: T[]): Collection<T>;
+export {};