sm-utility 2.1.0 → 2.1.2

package/excel/constants.d.ts

@@ -0,0 +1 @@
+export declare const ITEM_DEFAULT = "-";

package/excel/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ITEM_DEFAULT = void 0;
+exports.ITEM_DEFAULT = '-';

package/excel/enums.d.ts

@@ -0,0 +1,10 @@
+export declare const enum ExcelFormat {
+    DATE = "mmm - yy",
+    PERCENTAGE = "0%",
+    MONEY = "R$ 0.00",
+    ZERO_DEFAULT = "0",
+    NUMBER = "123"
+}
+export declare const enum ExcelType {
+    OPTIONS = "options"
+}

package/excel/enums.js

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

package/excel/excel-creator/excelCreator.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { ISpreadSheet } from "../interfaces";
+export declare class ExcelCreator {
+    createSync<T extends Record<string, string>>(sheets: ISpreadSheet<T>[]): Buffer;
+    createAsync<T extends Record<string, string>>(sheets: ISpreadSheet<T>[]): Promise<Buffer>;
+}

package/excel/excel-creator/excelCreator.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExcelCreator = void 0;
+const node_xlsx_1 = __importDefault(require("node-xlsx"));
+const path_1 = __importDefault(require("path"));
+const sheetExcelCreator_1 = require("./sheetExcelCreator");
+const thread_1 = require("../../thread");
+const logger_1 = require("../../logger");
+const RELATIVE_PATH = "./excelCreatorWorker/worker.ts";
+const EXCEL_CREATOR_WORKER_PATH = path_1.default.resolve(__dirname, RELATIVE_PATH);
+class ExcelCreator {
+    createSync(sheets) {
+        const builderSheets = sheets.map((sheet) => new sheetExcelCreator_1.SheetExcelCreator().create(sheet));
+        const buffer = node_xlsx_1.default.build(builderSheets);
+        return buffer;
+    }
+    async createAsync(sheets) {
+        const builderSheets = sheets.map((sheet) => new sheetExcelCreator_1.SheetExcelCreator().create(sheet));
+        const result = await thread_1.workerfy({
+            data: builderSheets,
+            path: EXCEL_CREATOR_WORKER_PATH,
+        });
+        if (result.error) {
+            logger_1.logger.info("Excel creation failed", {
+                context: sheets.map((s) => s.name),
+                err: result.error,
+            });
+        }
+        return result.file;
+    }
+}
+exports.ExcelCreator = ExcelCreator;

package/excel/excel-creator/excelCreatorCustomizer.d.ts

@@ -0,0 +1,6 @@
+import { IFormatStructure } from "../interfaces";
+export declare class ExcelCreatorCustomizer {
+    custom(element: string, structure: IFormatStructure | undefined): string;
+    private validOptionsValue;
+    private formatValue;
+}

package/excel/excel-creator/excelCreatorCustomizer.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExcelCreatorCustomizer = void 0;
+class ExcelCreatorCustomizer {
+    custom(element, structure) {
+        if (!structure)
+            return element;
+        let formattedValue = element;
+        if (structure.type === "options" /* OPTIONS */ && structure.options)
+            this.validOptionsValue(element, structure.options);
+        if (structure.customFormat)
+            formattedValue = this.formatValue(element, structure.customFormat);
+        if (structure.customFormatCallback)
+            formattedValue = structure.customFormatCallback(formattedValue);
+        return formattedValue;
+    }
+    validOptionsValue(value, customOptions) {
+        const isValid = customOptions.includes(value);
+        if (!isValid)
+            throw new Error("The element row is not in options custom items");
+    }
+    formatValue(value, customFormat) {
+        var _a;
+        switch (customFormat) {
+            case "123" /* NUMBER */:
+                return value.toString();
+            case "mmm - yy" /* DATE */: {
+                const date = new Date(value);
+                const month = date.getMonth();
+                const year = date.getFullYear();
+                return `${month} - ${year}`;
+            }
+            case "R$ 0.00" /* MONEY */:
+                return parseFloat(value).toLocaleString("pt-BR", {
+                    style: "currency",
+                    currency: "BRL",
+                });
+            case "0%" /* PERCENTAGE */:
+                return `${value}%`;
+            case "0" /* ZERO_DEFAULT */:
+                return (_a = value.toString()) !== null && _a !== void 0 ? _a : "0";
+        }
+    }
+}
+exports.ExcelCreatorCustomizer = ExcelCreatorCustomizer;

package/excel/excel-creator/excelCreatorWorker/createExcelTable.d.ts

@@ -0,0 +1,3 @@
+import { WorkSheet } from "node-xlsx";
+import { IWorkerResult } from "../../interfaces";
+export declare function createExcelTable(builderSheets: WorkSheet<string>[]): IWorkerResult;

package/excel/excel-creator/excelCreatorWorker/createExcelTable.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExcelTable = void 0;
+const node_xlsx_1 = __importDefault(require("node-xlsx"));
+function createExcelTable(builderSheets) {
+    try {
+        const file = node_xlsx_1.default.build(builderSheets);
+        return { file };
+    }
+    catch (err) {
+        const error = err;
+        return { error };
+    }
+}
+exports.createExcelTable = createExcelTable;

package/excel/excel-creator/excelCreatorWorker/worker.d.ts

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

package/excel/excel-creator/excelCreatorWorker/worker.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_threads_1 = require("worker_threads");
+const createExcelTable_1 = require("./createExcelTable");
+function main() {
+    if (worker_threads_1.parentPort) {
+        const workerResult = createExcelTable_1.createExcelTable(worker_threads_1.workerData.data);
+        worker_threads_1.parentPort.postMessage(workerResult);
+    }
+    else {
+        throw Error("The 'parentPort' is not available. This code should run within a worker context.");
+    }
+}
+main();

package/excel/excel-creator/sheetExcelCreator.d.ts

@@ -0,0 +1,10 @@
+import { WorkSheet } from "node-xlsx";
+import { ISpreadSheet } from "../interfaces";
+export declare class SheetExcelCreator {
+    create<T extends Record<string, string>>({ name, items, structures, }: ISpreadSheet<T>): WorkSheet<string>;
+    private buildSheetBuilder;
+    private buildSheetData;
+    private customItem;
+    private buildOptions;
+    private checkValidItem;
+}

package/excel/excel-creator/sheetExcelCreator.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SheetExcelCreator = void 0;
+const excelCreatorCustomizer_1 = require("./excelCreatorCustomizer");
+const constants_1 = require("../constants");
+class SheetExcelCreator {
+    create({ name, items, structures, }) {
+        const buildedSheetData = this.buildSheetData(items, structures);
+        const buildedOptions = this.buildOptions(structures);
+        const sheetBuilder = this.buildSheetBuilder(name, buildedSheetData, buildedOptions);
+        return sheetBuilder;
+    }
+    buildSheetBuilder(name, data, options) {
+        const sheetBuilder = { name, data, options };
+        return sheetBuilder;
+    }
+    buildSheetData(items, structures) {
+        const buildedItems = [];
+        const buildedTitleSheet = [
+            structures.map((struct) => struct.header.displayName),
+        ];
+        const buildedItemSheet = items.map((item) => structures.map((struct) => this.customItem(struct, item)));
+        const buildedSheet = buildedItems.concat(buildedTitleSheet, buildedItemSheet);
+        return buildedSheet;
+    }
+    customItem(struct, item) {
+        const { id, custom: itemCustom } = struct;
+        const itemField = item[id];
+        if (!this.checkValidItem(itemField))
+            return constants_1.ITEM_DEFAULT;
+        const customElement = new excelCreatorCustomizer_1.ExcelCreatorCustomizer().custom(itemField, itemCustom);
+        return customElement;
+    }
+    buildOptions(structures) {
+        const buildedColumnStyle = structures.map((struct) => ({
+            width: struct.width,
+        }));
+        const options = { ["!cols"]: buildedColumnStyle };
+        return options;
+    }
+    checkValidItem(item) {
+        return ![null, undefined, ""].includes(item);
+    }
+}
+exports.SheetExcelCreator = SheetExcelCreator;

package/excel/excel-parser/excelParser.d.ts

@@ -0,0 +1,5 @@
+import { IExcelParserData } from "../interfaces";
+export declare class ExcelParser {
+    parse<T = any>(data: IExcelParserData): Promise<T[][]>;
+    private deleteFile;
+}

package/excel/excel-parser/excelParser.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExcelParser = void 0;
+const node_xlsx_1 = __importDefault(require("node-xlsx"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const dirname_1 = require("../../dirname");
+const sheetExcelParser_1 = require("./sheetExcelParser");
+class ExcelParser {
+    async parse(data) {
+        const filePath = path_1.default.resolve(dirname_1.DIRNAME, "uploads", `${data.filename}`);
+        const sheets = node_xlsx_1.default.parse(filePath);
+        const parsedResult = sheets.map((sheet) => new sheetExcelParser_1.SheetExcelParser().parse(sheet));
+        await this.deleteFile(filePath);
+        return parsedResult;
+    }
+    async deleteFile(path) {
+        await fs_1.default.promises.stat(path);
+        await fs_1.default.promises.unlink(path);
+    }
+}
+exports.ExcelParser = ExcelParser;

package/excel/excel-parser/sheetExcelParser.d.ts

@@ -0,0 +1,8 @@
+import { IExcelSheet } from "../interfaces";
+export declare class SheetExcelParser {
+    parse<T>(sheet: IExcelSheet): T[];
+    private removingEmptyRows;
+    private extractHeadersFromExcelSheet;
+    private typeSheetCells;
+    private buildExcelResultRow;
+}

package/excel/excel-parser/sheetExcelParser.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SheetExcelParser = void 0;
+class SheetExcelParser {
+    parse(sheet) {
+        const headers = this.extractHeadersFromExcelSheet(sheet);
+        this.removingEmptyRows(sheet);
+        const sheetData = this.typeSheetCells(sheet, headers);
+        return sheetData;
+    }
+    removingEmptyRows(sheet) {
+        sheet.data = sheet.data.filter((row) => !row.every((item) => !item));
+    }
+    extractHeadersFromExcelSheet(sheet) {
+        const headers = sheet.data[0];
+        sheet.data.shift();
+        return headers;
+    }
+    typeSheetCells(sheet, headers) {
+        const sheetData = sheet.data.map((row) => {
+            const sheetRow = this.buildExcelResultRow(row, headers);
+            return sheetRow;
+        });
+        return sheetData;
+    }
+    buildExcelResultRow(row, headers) {
+        const buildedRow = {};
+        for (const [index, item] of row.entries()) {
+            const header = headers[index];
+            if (typeof item === "number") {
+                const value = parseFloat(item.toString());
+                buildedRow[header] = value;
+            }
+            else {
+                buildedRow[header] = item.toString();
+            }
+        }
+        return buildedRow;
+    }
+}
+exports.SheetExcelParser = SheetExcelParser;

package/excel/index.d.ts

@@ -0,0 +1,4 @@
+export { ExcelCreator } from './excel-creator/excelCreator';
+export { ExcelParser } from './excel-parser/excelParser';
+export { ExcelFormat, ExcelType } from './enums';
+export { ISpreadSheet, ISheetStructure, IFormatStructure, IExcelParserData, IExcelSheet, } from './interfaces';

package/excel/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExcelParser = exports.ExcelCreator = void 0;
+var excelCreator_1 = require("./excel-creator/excelCreator");
+Object.defineProperty(exports, "ExcelCreator", { enumerable: true, get: function () { return excelCreator_1.ExcelCreator; } });
+var excelParser_1 = require("./excel-parser/excelParser");
+Object.defineProperty(exports, "ExcelParser", { enumerable: true, get: function () { return excelParser_1.ExcelParser; } });

package/excel/interfaces.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+import { ExcelFormat, ExcelType } from "./enums";
+export interface ISpreadSheet<T> {
+    name: string;
+    items: T[];
+    structures: ISheetStructure[];
+}
+export interface ISheetStructure {
+    header: {
+        displayName: string;
+    };
+    id: string;
+    width: number;
+    custom?: IFormatStructure;
+}
+export interface IFormatStructure {
+    customFormat?: ExcelFormat;
+    type?: ExcelType;
+    options?: string[];
+    customFormatCallback?: (value: any) => string;
+}
+export interface IExcelParserData {
+    filename: string;
+}
+export interface IExcelSheet {
+    name: string;
+    data: string[][];
+}
+export declare type IWorkerResult = IWorkerSuccessResult | IWorkerFailedResult;
+export declare type IWorkerSuccessResult = {
+    file: Buffer;
+};
+export declare type IWorkerFailedResult = {
+    error: Error;
+};

package/excel/interfaces.js

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

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "sm-utility",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "description": "reusable utility codes for sm projects",
   "main": "index.js",
   "types": "./index.d.ts",
   "typings": "./index.d.ts",
   "scripts": {
     "clean": "rm -rf dist",
-    "prebuild":"npm run clean",
+    "prebuild": "npm run clean",
     "build": "tsc",
     "postbuild": "npm run copy-files",
     "copy-files": "copyfiles package.json README.md ./dist",
@@ -30,6 +30,7 @@
     "aws-sdk": "^2.1134.0",
     "axios": "^0.23.0",
     "express-winston": "^4.1.0",
+    "node-xlsx": "^0.23.0",
     "redis": "^4.1.0",
     "uuid": "^8.3.2",
     "winston": "^3.3.3"

package/thread/index.d.ts

@@ -0,0 +1,4 @@
+export declare function workerfy<T, K = unknown>(workerData: unknown & {
+    data: K;
+    path: string;
+}): Promise<T>;

package/thread/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workerfy = void 0;
+const worker_threads_1 = require("worker_threads");
+function workerfy(workerData) {
+    return new Promise((resolve, reject) => {
+        const worker = new worker_threads_1.Worker(workerData.path, {
+            workerData,
+            execArgv: ['-r', 'ts-node/register'],
+        });
+        worker.on('message', (msg) => {
+            resolve(msg);
+        });
+        worker.on('error', (error) => {
+            reject(error);
+        });
+        worker.on('exit', (code) => {
+            if (code !== 0)
+                reject(new Error(`Worker stopped with exit code ${code}`));
+        });
+    });
+}
+exports.workerfy = workerfy;