@nextage/nx-frame-be 1.0.1

package/build/common/base/sql-utils.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSQLModel = exports.TABLE_SYNC_PROMISES = exports.codedEntitySQLSchema = void 0;
+const sequelize_1 = __importDefault(require("sequelize"));
+const constants_1 = require("../constants");
+exports.codedEntitySQLSchema = {
+    code: { type: sequelize_1.default.STRING, allowNull: false, unique: true },
+    name: { type: sequelize_1.default.STRING }
+};
+exports.TABLE_SYNC_PROMISES = {};
+/**
+ *
+ * @param {*} modelName
+ * @param {*} schema
+ * @param {*} collection
+ */
+function loadSQLModel(modelName, modelDef, schema, tableName, schemaName, params = {}) {
+    var _a, _b, _c, _d;
+    if (!constants_1.APP.sqlz && !params.sqlz)
+        return;
+    const model = modelDef;
+    const sqlParams = {
+        sequelize: (_a = params.sqlz) !== null && _a !== void 0 ? _a : constants_1.APP.sqlz,
+        schema: schemaName,
+        createdAt: (_b = params.createdAt) !== null && _b !== void 0 ? _b : false,
+        updatedAt: (_c = params.updatedAt) !== null && _c !== void 0 ? _c : false,
+        tableName: tableName,
+        modelName: modelName
+    };
+    model.init(schema, sqlParams);
+    if (params.createTable) {
+        if (params.requires) {
+            const promises = ((_d = params.requires) !== null && _d !== void 0 ? _d : []).map((d) => { var _a; return (_a = exports.TABLE_SYNC_PROMISES[d]) !== null && _a !== void 0 ? _a : false; });
+            Promise.all(promises).then(() => {
+                exports.TABLE_SYNC_PROMISES[modelName] = model.sync();
+            });
+            return;
+        }
+        exports.TABLE_SYNC_PROMISES[modelName] = model.sync();
+    }
+    return model;
+}
+exports.loadSQLModel = loadSQLModel;
+// /**
+//  * 
+//  * @param {*} period 
+//  * @param {*} year 
+//  */
+// export function toFilterDatePeriod(period, year) {
+//   let values = getDatePeriod(period, year);
+//   return values ? { $gte: values[0], $lt: values[1] } : {};
+// }
+// export function checkDBSQLItem(idKey, model, item, logger = APP.logger) {
+//   if (!idKey || !model || !item || !item[idKey]) return (cb) => cb();
+//   let select    = {};
+//   select[idKey] = item[idKey];
+//   return (cb) => {
+//     model.findOneNative(select).then(res => {
+//       if (res) return cb();
+//       model.mgModel.create(item).then(res => {
+//         logger.info(`Created ${model.name} (${item[idKey]})`, logClassCtx(this));
+//         cb();
+//       });
+//     });
+//   }
+// }

package/build/common/constants.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { AppData } from './types';
+import { CryptoUtils } from './crypto';
+import { CryptoManager } from './manager/crypto-manager';
+export declare const APP: AppData;
+export declare const FILE_CONTENT_TYPES: {
+    none: string;
+    txt: string;
+    xml: string;
+    csv: string;
+    xls: string;
+    xlsx: string;
+};
+export declare const MIME_TYPES: {
+    types: string[];
+    extension: string;
+}[];
+export declare const REGEX: {
+    pwd: RegExp;
+    email: RegExp;
+    dataurl: RegExp;
+};
+export declare const BUFFER_NULL: Buffer;
+export declare const EVENT_TYPE: {};
+export declare const MODEL_CRUD_EVENT = "crudEvent";
+export declare const cryptoManager: CryptoManager;
+export declare const cryptoUtils: CryptoUtils;

package/build/common/constants.js

@@ -0,0 +1,70 @@
+"use strict";
+// import { CryptoManager } from './crypto-manager';
+// import { CryptoUtils }   from './crypto-utils';
+// import { PubSubManager } from './pubsub-manager';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cryptoUtils = exports.cryptoManager = exports.MODEL_CRUD_EVENT = exports.EVENT_TYPE = exports.BUFFER_NULL = exports.REGEX = exports.MIME_TYPES = exports.FILE_CONTENT_TYPES = exports.APP = void 0;
+const pubsub_manager_1 = require("./manager/pubsub-manager");
+const shutdown_manager_1 = require("./manager/shutdown-manager");
+const enums_1 = require("./enums");
+const crypto_1 = require("./crypto");
+const crypto_manager_1 = require("./manager/crypto-manager");
+exports.APP = {
+    status: enums_1.AppStatus.INIT,
+    logger: console,
+    prodMode: process.env.NODE_ENV === enums_1.AppMode.PROD, // prodMode(),
+    appName: process.env.APP_NAME || 'nx',
+    mongoModels: {},
+    streams: [],
+    dataScr: process.env.SECRET,
+    nxPubSub: new pubsub_manager_1.PubSubManager(),
+    shutdownMng: new shutdown_manager_1.ShutdownManager(),
+    config: { endpoint: {}, email: {}, jwt: {}, aws: {}, mongo: {}, logging: {}, invite: {}, msg: {} }
+};
+exports.FILE_CONTENT_TYPES = {
+    none: '',
+    txt: 'text/plain',
+    xml: 'text/xml',
+    csv: 'text/csv',
+    xls: 'application/vnd.ms-excel',
+    xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+};
+exports.MIME_TYPES = [
+    { types: ['text/rtf'], extension: 'rtf' },
+    { types: ['text/csv'], extension: 'csv' },
+    { types: ['text/plain'], extension: 'txt' },
+    { types: ['application/xml'], extension: 'xml' },
+    { types: ['application/json'], extension: 'json' },
+    { types: ['application/pdf'], extension: 'pdf' },
+    { types: ['application/msword'], extension: 'doc' },
+    { types: ['application/vnd.oasis.opendocument.text'], extension: 'odt' },
+    { types: ['application/vnd.openxmlformats-officedocument.wordprocessingml.document'], extension: 'docx' },
+    { types: ['application/vnd.ms-excel'], extension: 'xls' },
+    { types: ['application/vnd.oasis.opendocument.spreadsheet'], extension: 'ods' },
+    { types: ['application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'], extension: 'xlsx' },
+    { types: ['application/vnd.ms-powerpoint'], extension: 'ppt' },
+    { types: ['application/vnd.oasis.opendocument.presentation'], extension: 'odp' },
+    { types: ['application/vnd.openxmlformats-officedocument.presentationml.presentation'], extension: 'pptx' },
+    { types: ['image/gif'], extension: 'gif' },
+    { types: ['image/png'], extension: 'png' },
+    { types: ['image/jpeg'], extension: 'jpg' },
+    { types: ['image/bmp', 'image/x-ms-bmp'], extension: 'bmp' },
+    { types: ['audio/mp3', 'audio/mpeg'], extension: 'mp3' },
+    { types: ['audio/mp4', 'audio/x-m4a'], extension: 'm4a' },
+    { types: ['audio/wav', 'audio/wave', 'audio/x-wav'], extension: 'wav' },
+    { types: ['video/mp4'], extension: 'mp4' },
+    { types: ['video/mpeg'], extension: 'mpeg' },
+    { types: ['video/x-matroska'], extension: 'mkv' },
+    { types: ['application/zip'], extension: 'zip' }
+];
+exports.REGEX = {
+    pwd: /^(?!.*[ ]{2})(\s*(?:\S\s*){12,128})$/,
+    email: /^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/,
+    dataurl: /^data:.+\/(.+);base64,(.*)$/
+};
+exports.BUFFER_NULL = Buffer.from([0x00]);
+exports.EVENT_TYPE = {};
+exports.MODEL_CRUD_EVENT = 'crudEvent';
+// export const nxPubSub         = new PubSubManager();
+exports.cryptoManager = new crypto_manager_1.CryptoManager();
+exports.cryptoUtils = new crypto_1.CryptoUtils();

package/build/common/crypto/crypto.classes.d.ts

@@ -0,0 +1,100 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import crypto from 'crypto';
+import { Stream } from 'stream';
+import { NxObject } from '../interfaces';
+import { CertKeys, KeyAdditionalFieldAttrs } from './crypto.interfaces';
+import { KeyOptionsAttrs, SymKeyAttrs } from './crypto.interfaces';
+import { BaseModel } from '../base/base.model';
+/**
+ * SYMM/ASYMM KEY/KEYPAIR  TYPE CLASSES
+ */
+/**
+  * @class
+  * @param { string } publicKey  String represent the public key
+  * @param { string } privateKey String represent the private key
+ */
+export declare class AsymmetricKeyPair {
+    publicKey: crypto.KeyObject;
+    privateKey: crypto.KeyObject;
+    /**
+     *
+     * @param { CertKeys } certKeys  Strings representing the public anb private key
+     */
+    constructor({ publicKey, privateKey }: CertKeys);
+}
+/**
+ * @class
+ * @param { string } key  Specified string Key
+ * @param { string } iv   Specified string Initialization Vector
+ * @param { number } size Specified bit size for AES algorithm
+ */
+export declare class SymmetricKey {
+    key: string;
+    iv: string;
+    size: number;
+    /**
+     *
+     * @param { string } key  Specified string Key
+     * @param { string } iv   Specified string Initialization Vector
+     * @param { number } size Specified bit size for AES algorithm
+     */
+    constructor({ key, iv, size }: SymKeyAttrs);
+}
+/**
+ * @class
+ * @member model            the mongoose model where to save data
+ * @member filter           filter for identify the document to edit adding data
+ * @member path             the path where to save data ot data structure for a new document
+ * @member additionalFields the fields to add to the data when need to
+ * @member chunksize        size of the chunks for split private or public key into array of chunks, if not present full key is used
+ */
+export declare class KeyOptions {
+    key?: string;
+    model: BaseModel<any, any, any>;
+    path: string;
+    chunkSize: number;
+    filter?: NxObject;
+    additionalFields?: KeyAdditionalFieldAttrs[];
+    isChunked: boolean;
+    hasAdditionalFields: boolean;
+    hasFilter: boolean;
+    /**
+     * @param { BaseModel }            model            the mongoose model where to save data
+     * @param { object }               filter           filter for identify the document to edit adding data
+     * @param { string }               path             the path where to save data ot data structure for a new document
+     * @param { KeyAdditionalField[] } addiyionalFields the fields to add to the data when need to
+     * @param { number }               chunkSize        size of the chunks for split private or public key into array of chunks, if not present full key is used
+     */
+    constructor({ key, model, filter, path, additionalFields, chunkSize }: KeyOptionsAttrs);
+}
+/**
+ * @class
+ * @member publicKeyOptions  Options for the publicKey
+ * @member privateKeyOptions Options for the privateKey
+ */
+export declare class RSAKeyPairOptions {
+    publicKeyOptions: KeyOptions;
+    privateKeyOptions: KeyOptions;
+    /**
+     *
+     * @param { KeyOptions } publicKeyOptions
+     * @param { KeyOptions } privateKeyOptions
+     */
+    constructor(publicKeyOptions: KeyOptions, privateKeyOptions: KeyOptions);
+}
+/**
+ * @class
+ * @member symKey         :
+ * @member cypheredStream :
+ */
+export declare class KeyCypheredStreamPair {
+    symKey: SymmetricKey;
+    cypheredStream: Stream;
+    /**
+     *
+     * @param { SymmetricKey } symKey
+     * @param { Stream }       cypheredStream
+     */
+    constructor(symKey: SymmetricKey, cypheredStream: Stream);
+}

package/build/common/crypto/crypto.classes.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyCypheredStreamPair = exports.RSAKeyPairOptions = exports.KeyOptions = exports.SymmetricKey = exports.AsymmetricKeyPair = void 0;
+const stream_1 = require("stream");
+/**
+ * SYMM/ASYMM KEY/KEYPAIR  TYPE CLASSES
+ */
+/**
+  * @class
+  * @param { string } publicKey  String represent the public key
+  * @param { string } privateKey String represent the private key
+ */
+class AsymmetricKeyPair {
+    /**
+     *
+     * @param { CertKeys } certKeys  Strings representing the public anb private key
+     */
+    constructor({ publicKey, privateKey }) {
+        this.publicKey = publicKey;
+        this.privateKey = privateKey;
+    }
+}
+exports.AsymmetricKeyPair = AsymmetricKeyPair;
+/**
+ * @class
+ * @param { string } key  Specified string Key
+ * @param { string } iv   Specified string Initialization Vector
+ * @param { number } size Specified bit size for AES algorithm
+ */
+class SymmetricKey {
+    /**
+     *
+     * @param { string } key  Specified string Key
+     * @param { string } iv   Specified string Initialization Vector
+     * @param { number } size Specified bit size for AES algorithm
+     */
+    constructor({ key, iv, size }) {
+        this.key = key;
+        this.iv = iv;
+        this.size = size;
+    }
+}
+exports.SymmetricKey = SymmetricKey;
+/**
+ * RSA TYPE CLASSES
+ */
+/**
+ * @class
+ * @member path
+ * @member value
+ */
+class KeyAdditionalField {
+    constructor({ path, value }) {
+        this.path = path;
+        this.value = value;
+    }
+}
+/**
+ * @class
+ * @member model            the mongoose model where to save data
+ * @member filter           filter for identify the document to edit adding data
+ * @member path             the path where to save data ot data structure for a new document
+ * @member additionalFields the fields to add to the data when need to
+ * @member chunksize        size of the chunks for split private or public key into array of chunks, if not present full key is used
+ */
+class KeyOptions {
+    /**
+     * @param { BaseModel }            model            the mongoose model where to save data
+     * @param { object }               filter           filter for identify the document to edit adding data
+     * @param { string }               path             the path where to save data ot data structure for a new document
+     * @param { KeyAdditionalField[] } addiyionalFields the fields to add to the data when need to
+     * @param { number }               chunkSize        size of the chunks for split private or public key into array of chunks, if not present full key is used
+     */
+    constructor({ key, model, filter, path, additionalFields, chunkSize }) {
+        // Comodity Booleans
+        this.isChunked = false;
+        this.hasAdditionalFields = !!this.additionalFields;
+        this.hasFilter = !!this.filter;
+        if (!model && !key)
+            throw new Error("Error, model or key param not provided! model param is mandatory!");
+        if (!path && !key)
+            throw new Error("Error, path or key param not provided! path param is mandatory!");
+        this.key = key;
+        this.model = model;
+        this.filter = filter;
+        this.path = path;
+        this.additionalFields = additionalFields;
+        this.chunkSize = chunkSize;
+        // Comodity Booleans
+        this.isChunked = !!chunkSize;
+        this.hasAdditionalFields = !!additionalFields;
+        this.hasFilter = !!filter;
+    }
+}
+exports.KeyOptions = KeyOptions;
+/**
+ * @class
+ * @member publicKeyOptions  Options for the publicKey
+ * @member privateKeyOptions Options for the privateKey
+ */
+class RSAKeyPairOptions {
+    /**
+     *
+     * @param { KeyOptions } publicKeyOptions
+     * @param { KeyOptions } privateKeyOptions
+     */
+    constructor(publicKeyOptions, privateKeyOptions) {
+        try {
+            publicKeyOptions = new KeyOptions(publicKeyOptions);
+            privateKeyOptions = new KeyOptions(privateKeyOptions);
+        }
+        catch (ex) {
+            throw Error('publicKey options and/or privateKey options values are not instances or compatible with RSAKeyOptions');
+        }
+        /**
+         * @member { KeyOptions }
+         */
+        this.publicKeyOptions = publicKeyOptions;
+        /**
+         * @member { KeyOptions }
+         */
+        this.privateKeyOptions = privateKeyOptions;
+    }
+}
+exports.RSAKeyPairOptions = RSAKeyPairOptions;
+/**
+ * @class
+ * @member symKey         :
+ * @member cypheredStream :
+ */
+class KeyCypheredStreamPair {
+    /**
+     *
+     * @param { SymmetricKey } symKey
+     * @param { Stream }       cypheredStream
+     */
+    constructor(symKey, cypheredStream) {
+        if (!(symKey instanceof SymmetricKey))
+            throw new Error('symKey need to be of SymmetricKey type.');
+        if (!(cypheredStream instanceof stream_1.Stream))
+            throw new Error('cypheredStream need to be of Stream type.');
+        this.symKey = symKey;
+        this.cypheredStream = cypheredStream;
+    }
+}
+exports.KeyCypheredStreamPair = KeyCypheredStreamPair;

package/build/common/crypto/crypto.constants.d.ts

@@ -0,0 +1,68 @@
+import { NxTypeObject } from '../interfaces';
+import { KeyEncoding, KeySizeMap } from './crypto.interfaces';
+export declare const CRYPTO_ASYM_BITSIZE = 4096;
+export declare const CRYPTO_SYM_BITSIZE = 256;
+export declare const CRYPTO_ASYM_BITSIZE_LIST: number[];
+export declare const CRYPTO_PUB_KEY_ENCODING: KeyEncoding;
+export declare const CRYPTO_PRIV_KEY_ENCODING: KeyEncoding;
+export declare const CRYPTO_SYM_BITSIZE_MAP: NxTypeObject<KeySizeMap>;
+export declare enum CRYPTO_ERR_CODES {
+    BITSIZE = "ERR_INVALID_BITSIZE",
+    ARG_TYPE = "ERR_INVALID_ARG_TYPE",
+    ARG_INVALID = "ERR_INVALID_ARG",
+    NULL_ARG = "ERR_NULL_ARGS",
+    ASYM_ENC = "ERR_ASYM_ENC_FAIL",
+    ASYM_DEC = "ERR_ASYM_DEC_FAIL",
+    SYM_ENC = "ERR_SYM_ENC_FAIL",
+    SYM_DEC = "ERR_SYM_DEC_FAIL",
+    ASYM_KEYGEN = "ERR_ASYM_KEYGEN_FAIL",
+    SYM_KEYGEN = "ERR_SYM_KEYGEN_FAIL",
+    NOT_FOUND = "ERR_NOT_FOUND",
+    CHUNK_SIZE = "ERR_CHUNK_SIZE"
+}
+export declare const CRYPTO_ERRORS: {
+    SYM_BITSIZE: {
+        message: string;
+        code: CRYPTO_ERR_CODES;
+    };
+    SYM_DATA_TYPE: {
+        message: string;
+        code: CRYPTO_ERR_CODES;
+    };
+    ASYM_BITSIZE: {
+        message: string;
+        code: CRYPTO_ERR_CODES;
+    };
+    ASYM_PUB_ARGS: {
+        message: string;
+        code: CRYPTO_ERR_CODES;
+    };
+    ASYM_PRIV_ARGS: {
+        message: string;
+        code: CRYPTO_ERR_CODES;
+    };
+    KEY_OPTS_ARGS: {
+        message: string;
+        code: CRYPTO_ERR_CODES;
+    };
+    KEY_OPTS_PROPS: {
+        message: string;
+        code: CRYPTO_ERR_CODES;
+    };
+    PRIV_KEY_NOT_FOUND: {
+        message: string;
+        code: CRYPTO_ERR_CODES;
+    };
+    ENC_SYM_NOT_FOUND: {
+        message: string;
+        code: CRYPTO_ERR_CODES;
+    };
+    GEN_KEY_PAIR: {
+        message: string;
+        code: CRYPTO_ERR_CODES;
+    };
+    CHUNK_SIZE: {
+        message: string;
+        code: CRYPTO_ERR_CODES;
+    };
+};

package/build/common/crypto/crypto.constants.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CRYPTO_ERRORS = exports.CRYPTO_ERR_CODES = exports.CRYPTO_SYM_BITSIZE_MAP = exports.CRYPTO_PRIV_KEY_ENCODING = exports.CRYPTO_PUB_KEY_ENCODING = exports.CRYPTO_ASYM_BITSIZE_LIST = exports.CRYPTO_SYM_BITSIZE = exports.CRYPTO_ASYM_BITSIZE = void 0;
+exports.CRYPTO_ASYM_BITSIZE = 4096;
+exports.CRYPTO_SYM_BITSIZE = 256;
+exports.CRYPTO_ASYM_BITSIZE_LIST = [1024, 2048, 4096];
+exports.CRYPTO_PUB_KEY_ENCODING = { type: 'spki', format: 'pem' };
+exports.CRYPTO_PRIV_KEY_ENCODING = { type: 'pkcs8', format: 'pem' };
+exports.CRYPTO_SYM_BITSIZE_MAP = {
+    128: {
+        keySize: 128,
+        ivSize: 128,
+        saltSize: 256,
+        phraseSize: 256
+    },
+    192: {
+        keySize: 192,
+        ivSize: 128,
+        saltSize: 192,
+        phraseSize: 256
+    },
+    256: {
+        keySize: 256,
+        ivSize: 128,
+        saltSize: 128,
+        phraseSize: 256
+    }
+};
+var CRYPTO_ERR_CODES;
+(function (CRYPTO_ERR_CODES) {
+    CRYPTO_ERR_CODES["BITSIZE"] = "ERR_INVALID_BITSIZE";
+    CRYPTO_ERR_CODES["ARG_TYPE"] = "ERR_INVALID_ARG_TYPE";
+    CRYPTO_ERR_CODES["ARG_INVALID"] = "ERR_INVALID_ARG";
+    CRYPTO_ERR_CODES["NULL_ARG"] = "ERR_NULL_ARGS";
+    CRYPTO_ERR_CODES["ASYM_ENC"] = "ERR_ASYM_ENC_FAIL";
+    CRYPTO_ERR_CODES["ASYM_DEC"] = "ERR_ASYM_DEC_FAIL";
+    CRYPTO_ERR_CODES["SYM_ENC"] = "ERR_SYM_ENC_FAIL";
+    CRYPTO_ERR_CODES["SYM_DEC"] = "ERR_SYM_DEC_FAIL";
+    CRYPTO_ERR_CODES["ASYM_KEYGEN"] = "ERR_ASYM_KEYGEN_FAIL";
+    CRYPTO_ERR_CODES["SYM_KEYGEN"] = "ERR_SYM_KEYGEN_FAIL";
+    CRYPTO_ERR_CODES["NOT_FOUND"] = "ERR_NOT_FOUND";
+    CRYPTO_ERR_CODES["CHUNK_SIZE"] = "ERR_CHUNK_SIZE";
+})(CRYPTO_ERR_CODES || (exports.CRYPTO_ERR_CODES = CRYPTO_ERR_CODES = {}));
+;
+exports.CRYPTO_ERRORS = {
+    SYM_BITSIZE: { message: 'AES bit size not valid. Only 128/192/256 bit allowed.', code: CRYPTO_ERR_CODES.BITSIZE },
+    SYM_DATA_TYPE: { message: 'Type not supported, only "Stream", "String" or string primitive allowed.', code: CRYPTO_ERR_CODES.ARG_TYPE },
+    ASYM_BITSIZE: { message: 'RSA modulus size is not valid. Only 1024/2048/4096 bit allowed.', code: CRYPTO_ERR_CODES.BITSIZE },
+    ASYM_PUB_ARGS: { message: 'Public RSA Key and/or data arguments not supplied.', code: CRYPTO_ERR_CODES.NULL_ARG },
+    ASYM_PRIV_ARGS: { message: 'Private RSA Key and/or Encrypted Data arguments not supplied.', code: CRYPTO_ERR_CODES.NULL_ARG },
+    KEY_OPTS_ARGS: { message: 'keyOptions arguments not supplied', code: CRYPTO_ERR_CODES.NULL_ARG },
+    KEY_OPTS_PROPS: { message: '"model" and/or "filter" and/or "path" arguments not supplied. These arguments are needed to retrive a key', code: CRYPTO_ERR_CODES.NULL_ARG },
+    PRIV_KEY_NOT_FOUND: { message: 'Private Key not found.', code: CRYPTO_ERR_CODES.NOT_FOUND },
+    ENC_SYM_NOT_FOUND: { message: 'Cyphered symmetric Key not found.', code: CRYPTO_ERR_CODES.NOT_FOUND },
+    GEN_KEY_PAIR: { message: 'Cannot generate keyPair with supplied parameters.', code: CRYPTO_ERR_CODES.ARG_INVALID },
+    CHUNK_SIZE: { message: 'Provided chunkSize is different from original one.', code: CRYPTO_ERR_CODES.CHUNK_SIZE }
+};

package/build/common/crypto/crypto.error.d.ts

@@ -0,0 +1,4 @@
+export declare class CryptoError extends Error {
+    code: string;
+    constructor(message: string | undefined, code: string);
+}

package/build/common/crypto/crypto.error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoError = void 0;
+class CryptoError extends Error {
+    constructor(message = 'Crypto Error', code) {
+        super(message);
+        this.code = code;
+    }
+}
+exports.CryptoError = CryptoError;

package/build/common/crypto/crypto.interfaces.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import crypto from 'crypto';
+import { NxObject } from '../interfaces';
+import { BaseModel } from '../base/base.model';
+export interface KeySizeMap {
+    keySize: number;
+    ivSize: number;
+    saltSize: number;
+    phraseSize: number;
+}
+export interface KeyEncoding {
+    type: string;
+    format: string;
+}
+export interface RSAKeyPair {
+    publicKey: string;
+    privateKey: string;
+}
+export interface CertKeys {
+    publicKey: crypto.KeyObject;
+    privateKey: crypto.KeyObject;
+    ca?: string;
+}
+export interface SymKeyAttrs {
+    key: string;
+    iv: string;
+    size: number;
+}
+export interface KeyOptionsAttrs {
+    key?: string;
+    model: BaseModel<any, any, any>;
+    path: string;
+    chunkSize: number;
+    filter?: NxObject;
+    additionalFields?: KeyAdditionalFieldAttrs[];
+}
+export interface KeyAdditionalFieldAttrs {
+    path: string;
+    value: any;
+}
+export interface BlindIndexOptions {
+    hasher?: any;
+    iterations?: number;
+    keySize?: number;
+    normalize?: boolean;
+}

package/build/common/crypto/crypto.interfaces.js

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