gyomu 0.1.0

package/lib/buffer.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufferToArrayBuffer = exports.arrayBufferToString = exports.stringToArrayBuffer = void 0;
+const stringToArrayBuffer = (source) => {
+    const encoder = new TextEncoder();
+    return encoder.encode(source).buffer;
+};
+exports.stringToArrayBuffer = stringToArrayBuffer;
+const arrayBufferToString = (source) => {
+    const decoder = new TextDecoder('utf-8');
+    return decoder.decode(source);
+};
+exports.arrayBufferToString = arrayBufferToString;
+const bufferToArrayBuffer = (buffer) => {
+    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+    // const ab = new ArrayBuffer(buffer.length);
+    // const view = new Uint8Array(ab);
+    // for (let i = 0; i < buffer.length; i++) {
+    //   view[i] = buffer[i];
+    // }
+    // return ab;
+};
+exports.bufferToArrayBuffer = bufferToArrayBuffer;

package/lib/configurator.d.ts

@@ -0,0 +1,16 @@
+import { User } from './user';
+export interface Configurator {
+    readonly machineName: string;
+    readonly address: string;
+    readonly userId: string;
+    readonly uniqueInstanceIdPerMachine: number;
+    readonly region: string;
+    readonly user: User;
+    readonly mode: string;
+    applicationId: () => number;
+    setApplicationId: (id: number) => void;
+}
+export declare class ConfigurationFactory {
+    #private;
+    static getInstance: () => Configurator;
+}

package/lib/configurator.js

@@ -0,0 +1,53 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _BaseConfigurator_applicationId, _a, _ConfigurationFactory_config;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurationFactory = void 0;
+const os_1 = require("os");
+const process_1 = require("process");
+const user_1 = require("./user");
+const GYOMU_COMMON_MODE = 'GYOMU_COMMON_MODE';
+class BaseConfigurator {
+    constructor(user, applicationId = -1) {
+        var _b;
+        _BaseConfigurator_applicationId.set(this, void 0);
+        this.applicationId = () => {
+            return __classPrivateFieldGet(this, _BaseConfigurator_applicationId, "f");
+        };
+        this.setApplicationId = (id) => {
+            __classPrivateFieldSet(this, _BaseConfigurator_applicationId, id, "f");
+        };
+        this.user = user;
+        this.userId = user.userId;
+        this.machineName = (0, os_1.hostname)();
+        const nets = (0, os_1.networkInterfaces)();
+        const net = (_b = nets['en0']) === null || _b === void 0 ? void 0 : _b.find((v) => v.family === 'IPv4');
+        this.address = !!net ? net.address : '';
+        __classPrivateFieldSet(this, _BaseConfigurator_applicationId, applicationId, "f");
+        this.uniqueInstanceIdPerMachine = process_1.pid;
+        this.region = this.user.region;
+        this.mode = process_1.env.GYOMU_COMMON_MODE || 'Development';
+    }
+}
+_BaseConfigurator_applicationId = new WeakMap();
+class ConfigurationFactory {
+}
+exports.ConfigurationFactory = ConfigurationFactory;
+_a = ConfigurationFactory;
+_ConfigurationFactory_config = { value: void 0 };
+ConfigurationFactory.getInstance = () => {
+    if (!__classPrivateFieldGet(ConfigurationFactory, _a, "f", _ConfigurationFactory_config)) {
+        __classPrivateFieldSet(ConfigurationFactory, _a, new BaseConfigurator(user_1.UserFactory.getCurrentUser()), "f", _ConfigurationFactory_config);
+    }
+    return __classPrivateFieldGet(ConfigurationFactory, _a, "f", _ConfigurationFactory_config);
+};

package/lib/dateOperation.d.ts

@@ -0,0 +1,3 @@
+export declare const createDateOnly: (year: number, one_base_month: number, day: number) => Date;
+export declare const createDateFromYYYYMMDD: (yyyyMMdd: string) => Date;
+export declare const extractDateOnly: (date: Date) => Date;

package/lib/dateOperation.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDateOnly = exports.createDateFromYYYYMMDD = exports.createDateOnly = void 0;
+const createDateOnly = (year, one_base_month, day) => {
+    const dateString = `${year}-${('00' + one_base_month).slice(-2)}-${('00' + day).slice(-2)}`;
+    return new Date(dateString);
+};
+exports.createDateOnly = createDateOnly;
+const createDateFromYYYYMMDD = (yyyyMMdd) => {
+    const dateString = yyyyMMdd.substring(0, 4) +
+        '-' +
+        yyyyMMdd.substring(4, 6) +
+        '-' +
+        yyyyMMdd.substring(6);
+    return new Date(dateString);
+};
+exports.createDateFromYYYYMMDD = createDateFromYYYYMMDD;
+const extractDateOnly = (date) => {
+    const dateString = `${date.getFullYear()}-${('00' +
+        (date.getMonth() + 1)).slice(-2)}-${('00' + date.getDate()).slice(-2)}`;
+    return new Date(dateString);
+};
+exports.extractDateOnly = extractDateOnly;

package/lib/dbsingleton.d.ts

@@ -0,0 +1,11 @@
+import { PrismaClient } from '@prisma/client';
+import { DeepMockProxy } from 'jest-mock-extended';
+export declare type Context = {
+    prisma: PrismaClient;
+};
+export declare type MockContext = {
+    prisma: DeepMockProxy<PrismaClient>;
+};
+export declare const createMockContext: () => MockContext;
+declare const prisma: PrismaClient<import(".prisma/client").Prisma.PrismaClientOptions, never, import(".prisma/client").Prisma.RejectOnNotFound | import(".prisma/client").Prisma.RejectPerOperation | undefined>;
+export default prisma;

package/lib/dbsingleton.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockContext = void 0;
+const client_1 = require("@prisma/client");
+const jest_mock_extended_1 = require("jest-mock-extended");
+const createMockContext = () => {
+    return {
+        prisma: (0, jest_mock_extended_1.mockDeep)(),
+    };
+};
+exports.createMockContext = createMockContext;
+const prisma = new client_1.PrismaClient();
+exports.default = prisma;

package/lib/dbutil.d.ts

@@ -0,0 +1,3 @@
+import { DBError } from './errors';
+import { PromiseResult } from './result';
+export declare function genericDBFunction<T>(actionName: string, dbFunc: (...args: any) => PromiseResult<T, DBError>, args: any[]): PromiseResult<T, DBError>;

package/lib/dbutil.js

@@ -0,0 +1,44 @@
+"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.genericDBFunction = void 0;
+const client_1 = require("@prisma/client");
+const errors_1 = require("./errors");
+const result_1 = require("./result");
+function genericDBFunction(actionName, dbFunc, args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                //console.log('calling');
+                const result = yield dbFunc(...args);
+                //console.log('called');
+                resolve(result);
+            }
+            catch (e) {
+                if (e instanceof client_1.Prisma.PrismaClientKnownRequestError ||
+                    e instanceof client_1.Prisma.PrismaClientUnknownRequestError ||
+                    e instanceof client_1.Prisma.PrismaClientValidationError) {
+                    resolve(new result_1.Failure(new errors_1.DBError(`Fail: ${actionName}`, e)));
+                }
+                else if (e instanceof errors_1.CriticalError) {
+                    reject(e);
+                }
+                else if (e instanceof client_1.Prisma.PrismaClientRustPanicError) {
+                    reject(new errors_1.CriticalError('Critical error on Prisma. Need to terminate the application', e));
+                }
+                else {
+                    resolve(new result_1.Failure(new errors_1.DBError(`Unknown Failure: ${actionName}`, e)));
+                }
+            }
+        }));
+    });
+}
+exports.genericDBFunction = genericDBFunction;

package/lib/dictionary.d.ts

@@ -0,0 +1,8 @@
+export declare class DictionaryAccess {
+    static build<K, R>(key: K, record: R, data: Map<K, Array<R>>): void;
+    static build2<K1, K2, R>(key1: K1, key2: K2, record: R, data: Map<K1, Map<K2, Array<R>>>): void;
+    static build3<K1, K2, K3, R>(key1: K1, key2: K2, key3: K3, record: R, data: Map<K1, Map<K2, Map<K3, Array<R>>>>): void;
+    static build4<K1, K2, K3, K4, R>(key1: K1, key2: K2, key3: K3, key4: K4, record: R, data: Map<K1, Map<K2, Map<K3, Map<K4, Array<R>>>>>): void;
+    static build5<K1, K2, K3, K4, K5, R>(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, record: R, data: Map<K1, Map<K2, Map<K3, Map<K4, Map<K5, Array<R>>>>>>): void;
+    static build6<K1, K2, K3, K4, K5, K6, R>(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, record: R, data: Map<K1, Map<K2, Map<K3, Map<K4, Map<K5, Map<K6, Array<R>>>>>>>): void;
+}

package/lib/dictionary.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DictionaryAccess = void 0;
+class DictionaryAccess {
+    static build(key, record, data) {
+        const values = data.get(key);
+        if (!values) {
+            data.set(key, new Array(record));
+        }
+        else {
+            values.push(record);
+        }
+    }
+    static build2(key1, key2, record, data) {
+        let values = data.get(key1);
+        if (!values) {
+            data.set(key1, new Map());
+            values = data.get(key1);
+        }
+        DictionaryAccess.build(key2, record, values);
+    }
+    static build3(key1, key2, key3, record, data) {
+        let values = data.get(key1);
+        if (!values) {
+            data.set(key1, new Map());
+            values = data.get(key1);
+        }
+        DictionaryAccess.build2(key2, key3, record, values);
+    }
+    static build4(key1, key2, key3, key4, record, data) {
+        let values = data.get(key1);
+        if (!values) {
+            data.set(key1, new Map());
+            values = data.get(key1);
+        }
+        DictionaryAccess.build3(key2, key3, key4, record, values);
+    }
+    static build5(key1, key2, key3, key4, key5, record, data) {
+        let values = data.get(key1);
+        if (!values) {
+            data.set(key1, new Map());
+            values = data.get(key1);
+        }
+        DictionaryAccess.build4(key2, key3, key4, key5, record, values);
+    }
+    static build6(key1, key2, key3, key4, key5, key6, record, data) {
+        let values = data.get(key1);
+        if (!values) {
+            data.set(key1, new Map());
+            values = data.get(key1);
+        }
+        DictionaryAccess.build5(key2, key3, key4, key5, key6, record, values);
+    }
+}
+exports.DictionaryAccess = DictionaryAccess;

package/lib/encryption.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+export declare const aesEncryptBufferByKeyFile: (plainBuffer: ArrayBuffer, keyFilename: string) => Buffer;
+export declare const aesEncrypt: (plain: string, key: string) => string;
+export declare const aesEncryptBuffer: (plainBuffer: ArrayBuffer, keyBuffer: ArrayBuffer) => Buffer;
+export declare const aesDecryptBuffer: (encryptedBuffer: Buffer, keyBuffer: ArrayBuffer) => Buffer;
+export declare const aesDecryptBufferByKeyFile: (encryptedBuffer: Buffer, keyFilename: string) => Buffer;
+export declare const aesDecrypt: (encrypted: string, key: string) => string;
+export declare const pkiEncrypt: (publicKey: Buffer, data: Buffer) => Buffer;
+export declare const pkiFileEncrypt: (publicKeyFilename: string, data: Buffer) => Buffer;
+export declare const pkiFileEncrypt2Base64: (publicKeyFilename: string, data: Buffer) => string;
+export declare const pkiEncryptString: (publicKeyFilename: string, data: string) => string;
+export declare const pkiFileEncryptToFile: (publicKeyFilename: string, plainFilename: string, encryptedFilename: string) => void;
+export declare const pkiDecrypt: (privateKey: Buffer, data: Buffer) => Buffer;
+export declare const pkiFileDecrypt: (privateKeyFilename: string, data: Buffer) => Buffer;
+export declare const pkiFileDecrypt2Base64: (privateKeyFilename: string, data: Buffer) => string;
+export declare const pkiFileDecryptString: (privateKeyFilename: string, data: string) => string;
+export declare const pkiFileDecryptFile: (privateKeyFilename: string, encryptedFilename: string, decryptedFilename: string) => void;

package/lib/encryption.js

@@ -0,0 +1,202 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pkiFileDecryptFile = exports.pkiFileDecryptString = exports.pkiFileDecrypt2Base64 = exports.pkiFileDecrypt = exports.pkiDecrypt = exports.pkiFileEncryptToFile = exports.pkiEncryptString = exports.pkiFileEncrypt2Base64 = exports.pkiFileEncrypt = exports.pkiEncrypt = exports.aesDecrypt = exports.aesDecryptBufferByKeyFile = exports.aesDecryptBuffer = exports.aesEncryptBuffer = exports.aesEncrypt = exports.aesEncryptBufferByKeyFile = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const base64_1 = require("./base64");
+const buffer_1 = require("./buffer");
+const fs_1 = require("fs");
+const aesEncryptBufferByKeyFile = (plainBuffer, keyFilename) => {
+    const keyBuffer = (0, fs_1.readFileSync)(keyFilename);
+    const keyArrayBuffer = (0, buffer_1.bufferToArrayBuffer)(keyBuffer);
+    return (0, exports.aesEncryptBuffer)(plainBuffer, keyArrayBuffer);
+};
+exports.aesEncryptBufferByKeyFile = aesEncryptBufferByKeyFile;
+const aesEncrypt = (plain, key) => {
+    const originalBuffer = (0, buffer_1.stringToArrayBuffer)(plain);
+    const encryptedBuffer = (0, exports.aesEncryptBuffer)(originalBuffer, getKey(key));
+    return (0, base64_1.buffer2Base64String)(encryptedBuffer);
+};
+exports.aesEncrypt = aesEncrypt;
+const aesEncryptBuffer = (plainBuffer, keyBuffer) => {
+    const keyLength = keyBuffer.byteLength;
+    console.log('KeyLength', keyLength);
+    if (keyLength !== 16 && keyLength !== 32)
+        throw new Error('Invalid Key Length');
+    const originalData = new DataView(plainBuffer);
+    const iv = crypto_1.default.randomBytes(16);
+    const encryptionKey = new DataView(keyBuffer);
+    const cipher = crypto_1.default.createCipheriv(keyLength === 16 ? 'aes-128-gcm' : 'aes-256-gcm', encryptionKey, iv);
+    const chunks = [
+        cipher.update(originalData),
+        cipher.final(),
+    ];
+    const encryptedBuffer = Buffer.concat([
+        iv,
+        chunks[0],
+        chunks[1],
+        cipher.getAuthTag(),
+    ]);
+    return encryptedBuffer;
+};
+exports.aesEncryptBuffer = aesEncryptBuffer;
+const aesDecryptBuffer = (encryptedBuffer, keyBuffer) => {
+    const iv = encryptedBuffer.subarray(0, 16); //Nonce
+    const tag = encryptedBuffer.subarray(encryptedBuffer.length - 16); //Tag
+    const encryptedData = encryptedBuffer.subarray(16, encryptedBuffer.length - 16);
+    const keyLength = keyBuffer.byteLength;
+    const encryptionKey = new DataView(keyBuffer);
+    const decipher = crypto_1.default.createDecipheriv(keyLength === 16 ? 'aes-128-gcm' : 'aes-256-gcm', encryptionKey, iv);
+    const chunks = [];
+    chunks.push(decipher.update(encryptedData));
+    decipher.setAuthTag(tag);
+    chunks.push(decipher.final());
+    return Buffer.concat(chunks);
+};
+exports.aesDecryptBuffer = aesDecryptBuffer;
+const aesDecryptBufferByKeyFile = (encryptedBuffer, keyFilename) => {
+    const keyBuffer = (0, fs_1.readFileSync)(keyFilename);
+    const keyArrayBuffer = (0, buffer_1.bufferToArrayBuffer)(keyBuffer);
+    return (0, exports.aesDecryptBuffer)(encryptedBuffer, keyArrayBuffer);
+};
+exports.aesDecryptBufferByKeyFile = aesDecryptBufferByKeyFile;
+const aesDecrypt = (encrypted, key) => {
+    const encryptedBuffer = (0, base64_1.base64String2Buffer)(encrypted);
+    const decryptedBuffer = (0, exports.aesDecryptBuffer)(encryptedBuffer, getKey(key));
+    return (0, buffer_1.arrayBufferToString)(decryptedBuffer);
+    // const encryptedBuffer = base64String2Buffer(encrypted);
+    // const iv = encryptedBuffer.subarray(0, 16); //Nonce
+    // const tag = encryptedBuffer.subarray(encryptedBuffer.length - 16); //Tag
+    // const encryptedData = encryptedBuffer.subarray(
+    //   16,
+    //   encryptedBuffer.length - 16
+    // );
+    // // console.log('Total', encryptedBuffer.byteLength);
+    // // console.log('iv', iv.byteLength);
+    // // console.log('tag', tag.byteLength);
+    // // console.log('encryptedData', encryptedData.byteLength);
+    // const encryptionKey = getKey(key);
+    // const decipher = crypto.createDecipheriv('aes-128-gcm', encryptionKey, iv);
+    // const chunks: Buffer[] = [];
+    // chunks.push(decipher.update(encryptedData));
+    // decipher.setAuthTag(tag);
+    // chunks.push(decipher.final());
+    // return bufferToString(Buffer.concat(chunks));
+};
+exports.aesDecrypt = aesDecrypt;
+const getKey = (key) => {
+    const arrayBuffer = (0, buffer_1.stringToArrayBuffer)(fixKeylength(key));
+    //console.log(arrayBuffer.byteLength);
+    return arrayBuffer;
+};
+const getKeyOld = (key) => {
+    const arrayBuffer = (0, buffer_1.stringToArrayBuffer)(fixKeylength(key));
+    //console.log(arrayBuffer.byteLength);
+    return new DataView(arrayBuffer);
+};
+// const getKey = async (key: string): Promise<CryptoKey> => {
+//   const cryptoKey = await crypto.subtle.importKey(
+//     'raw',
+//     stringToBuffer(fixKeylength(key)),
+//     {
+//       //this is the algorithm options
+//       name: 'AES-GCM',
+//       length: 16,
+//     },
+//     true, // whether the key is extractable
+//     ['encrypt', 'decrypt'] // usages
+//   );
+//   return cryptoKey;
+// };
+const fixKeylength = (key) => {
+    const keyLength = key.length;
+    if (keyLength < 16) {
+        return key.padEnd(16, ' ');
+    }
+    else if (keyLength == 16) {
+        return key;
+    }
+    else if (keyLength < 32) {
+        return key.padEnd(32, ' ');
+    }
+    else if (keyLength === 32) {
+        return key;
+    }
+    else {
+        throw new Error('Invalid Key Length: ' + key.length);
+    }
+};
+const pkiEncrypt = (publicKey, data) => {
+    return crypto_1.default.publicEncrypt(publicKey, data);
+};
+exports.pkiEncrypt = pkiEncrypt;
+// export const keyAESEncrypt2Base64 = (key: Buffer, data: Buffer): string => {
+//   return buffer2Base64String(keyAESEncrypt(key, data));
+// };
+// export const keyAESEncryptString = (key: Buffer, data: string): string => {
+//   return keyAESEncrypt2Base64(key, Buffer.from(data));
+// };
+const pkiFileEncrypt = (publicKeyFilename, data) => {
+    return (0, exports.pkiEncrypt)((0, fs_1.readFileSync)(publicKeyFilename), data);
+};
+exports.pkiFileEncrypt = pkiFileEncrypt;
+const pkiFileEncrypt2Base64 = (publicKeyFilename, data) => {
+    return (0, base64_1.buffer2Base64String)((0, exports.pkiFileEncrypt)(publicKeyFilename, data));
+};
+exports.pkiFileEncrypt2Base64 = pkiFileEncrypt2Base64;
+const pkiEncryptString = (publicKeyFilename, data) => {
+    return (0, exports.pkiFileEncrypt2Base64)(publicKeyFilename, Buffer.from(data));
+};
+exports.pkiEncryptString = pkiEncryptString;
+const pkiFileEncryptToFile = (publicKeyFilename, plainFilename, encryptedFilename) => {
+    (0, fs_1.writeFileSync)(encryptedFilename, (0, exports.pkiFileEncrypt)(publicKeyFilename, (0, fs_1.readFileSync)(plainFilename)));
+};
+exports.pkiFileEncryptToFile = pkiFileEncryptToFile;
+const pkiDecrypt = (privateKey, data) => {
+    return crypto_1.default.privateDecrypt(privateKey, data);
+};
+exports.pkiDecrypt = pkiDecrypt;
+// export const keyAESDecrypt2Base64 = (key: Buffer, data: Buffer): string => {
+//   return buffer2Base64String(keyAESDecrypt(key, data));
+// };
+// export const keyAESDeccryptString = (key: Buffer, data: string): string => {
+//   return keyAESDecrypt2Base64(key, Buffer.from(data));
+// };
+const pkiFileDecrypt = (privateKeyFilename, data) => {
+    return (0, exports.pkiDecrypt)((0, fs_1.readFileSync)(privateKeyFilename), data);
+};
+exports.pkiFileDecrypt = pkiFileDecrypt;
+const pkiFileDecrypt2Base64 = (privateKeyFilename, data) => {
+    return (0, base64_1.buffer2Base64String)((0, exports.pkiFileDecrypt)(privateKeyFilename, data));
+};
+exports.pkiFileDecrypt2Base64 = pkiFileDecrypt2Base64;
+const pkiFileDecryptString = (privateKeyFilename, data) => {
+    return (0, exports.pkiFileDecrypt2Base64)(privateKeyFilename, Buffer.from(data));
+};
+exports.pkiFileDecryptString = pkiFileDecryptString;
+const pkiFileDecryptFile = (privateKeyFilename, encryptedFilename, decryptedFilename) => {
+    (0, fs_1.writeFileSync)(decryptedFilename, (0, exports.pkiFileDecrypt)(privateKeyFilename, (0, fs_1.readFileSync)(encryptedFilename)));
+};
+exports.pkiFileDecryptFile = pkiFileDecryptFile;
+// export const aesDecryptOld = (encrypted: string, key: string): string => {
+//   const encryptedBuffer = base64String2Buffer(encrypted);
+//   const iv = encryptedBuffer.subarray(0, 16); //Nonce
+//   const tag = encryptedBuffer.subarray(encryptedBuffer.length - 16); //Tag
+//   const encryptedData = encryptedBuffer.subarray(
+//     16,
+//     encryptedBuffer.length - 16
+//   );
+//   // console.log('Total', encryptedBuffer.byteLength);
+//   // console.log('iv', iv.byteLength);
+//   // console.log('tag', tag.byteLength);
+//   // console.log('encryptedData', encryptedData.byteLength);
+//   const encryptionKey = getKeyOld(key);
+//   const decipher = crypto.createDecipheriv('aes-128-gcm', encryptionKey, iv);
+//   const chunks: Buffer[] = [];
+//   chunks.push(decipher.update(encryptedData));
+//   decipher.setAuthTag(tag);
+//   chunks.push(decipher.final());
+//   return arrayBufferToString(Buffer.concat(chunks));
+// };

package/lib/errors.d.ts

@@ -0,0 +1,31 @@
+export declare class BaseError extends Error {
+    innerError?: Error;
+    constructor(message: string, innerError?: Error);
+}
+export declare class ValueError extends BaseError {
+    constructor(message: string, innerError?: Error);
+}
+export declare class ArchiveError extends BaseError {
+    constructor(message: string, innerError?: Error);
+}
+export declare class TimeoutError extends BaseError {
+    constructor(message: string, innerError?: Error);
+}
+export declare class AccessError extends BaseError {
+    constructor(message: string, innerError?: Error);
+}
+export declare class WebParseError extends BaseError {
+    constructor(message: string, innerError?: Error);
+}
+export declare class ParseError extends BaseError {
+    constructor(message: string, innerError?: Error);
+}
+export declare class DBError extends BaseError {
+    constructor(message: string, innerError?: Error);
+}
+export declare class CriticalError extends BaseError {
+    constructor(message: string, innerError?: Error);
+}
+export declare class NetworkError extends BaseError {
+    constructor(message: string, innerError?: Error);
+}

package/lib/errors.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkError = exports.CriticalError = exports.DBError = exports.ParseError = exports.WebParseError = exports.AccessError = exports.TimeoutError = exports.ArchiveError = exports.ValueError = exports.BaseError = void 0;
+class BaseError extends Error {
+    constructor(message, innerError) {
+        super(message);
+        this.innerError = innerError;
+    }
+}
+exports.BaseError = BaseError;
+class ValueError extends BaseError {
+    constructor(message, innerError) {
+        super(message, innerError);
+    }
+}
+exports.ValueError = ValueError;
+class ArchiveError extends BaseError {
+    constructor(message, innerError) {
+        super(message, innerError);
+    }
+}
+exports.ArchiveError = ArchiveError;
+class TimeoutError extends BaseError {
+    constructor(message, innerError) {
+        super(message, innerError);
+    }
+}
+exports.TimeoutError = TimeoutError;
+class AccessError extends BaseError {
+    constructor(message, innerError) {
+        super(message, innerError);
+    }
+}
+exports.AccessError = AccessError;
+class WebParseError extends BaseError {
+    constructor(message, innerError) {
+        super(message, innerError);
+    }
+}
+exports.WebParseError = WebParseError;
+class ParseError extends BaseError {
+    constructor(message, innerError) {
+        super(message, innerError);
+    }
+}
+exports.ParseError = ParseError;
+class DBError extends BaseError {
+    constructor(message, innerError) {
+        super(message, innerError);
+    }
+}
+exports.DBError = DBError;
+class CriticalError extends BaseError {
+    constructor(message, innerError) {
+        super(message, innerError);
+    }
+}
+exports.CriticalError = CriticalError;
+class NetworkError extends BaseError {
+    constructor(message, innerError) {
+        super(message, innerError);
+    }
+}
+exports.NetworkError = NetworkError;

package/lib/excel.d.ts

@@ -0,0 +1 @@
+export declare const exportDictionaryArrayTable: (excelFilename: string, mapArray: Array<Map<string, string>>, sheetName: string) => void;

package/lib/excel.js

@@ -0,0 +1,34 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportDictionaryArrayTable = void 0;
+const XLSX = __importStar(require("xlsx"));
+const exportDictionaryArrayTable = (excelFilename, mapArray, sheetName) => {
+    const worksheet = XLSX.utils.json_to_sheet(mapArray);
+    const workbook = XLSX.utils.book_new();
+    XLSX.utils.book_append_sheet(workbook, worksheet, sheetName);
+    XLSX.writeFile(workbook, excelFilename);
+};
+exports.exportDictionaryArrayTable = exportDictionaryArrayTable;