opticore-webapp-core 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,438 @@
+import { StackTraceError } from 'opticore-catch-exception-error';
+import mySQL from 'mysql';
+import { ConnectionOptions } from 'tls';
+import { CustomTypesConfig } from 'pg';
+import { ServerResponse, IncomingMessage } from 'node:http';
+
+declare class SAsymmetricCryptionDataWithPrivateRSAKey {
+    private static log;
+    /**
+     *
+     * @param rsaKey
+     * @param keyType
+     * @protected
+     *
+     * Return ErrorHandler | string
+     */
+    protected static verifyExistingKey(rsaKey: string, keyType: string): StackTraceError | string;
+    /**
+     *
+     * @param privateKey
+     * @param payload
+     * @private
+     *
+     * Return Buffer
+     */
+    private static encryptionWithPrivateKey;
+    /**
+     *
+     * @param privateKey
+     * @param publicKey
+     * @param payload
+     * @private
+     */
+    private static decryptionWithPublicKey;
+    /**
+     *
+     * @param privateKey
+     * @param payload
+     * @private
+     */
+    private static signWithRSAKey;
+    /**
+     *
+     * @param privateKey
+     * @param publicKey
+     * @param payload
+     */
+    static verifyRSAKey(privateKey: string, publicKey: string, payload: any): string | Error;
+    /**
+     *
+     * @param props
+     * @param name
+     * @param status
+     * @private
+     */
+    private static traceError;
+}
+
+declare class SAsymmetricCryptionDataWithPublicRSAKey {
+    private static log;
+    /**
+     *
+     * @param rsaKey
+     * @param keyType
+     * @protected
+     */
+    protected static verifyExistingKey(rsaKey: string, keyType: string): string | Error;
+    /**
+     *
+     * @param publicKey
+     * @param payload
+     * @private
+     */
+    private static encryptionWithPublicKey;
+    /**
+     *
+     * @param privateKey
+     * @param publicKey
+     * @param payload
+     * @private
+     */
+    private static decryptionWithPrivateKey;
+    /**
+     *
+     * @param publicKey
+     * @param payload
+     * @private
+     */
+    private static signWithPublicRSAKey;
+    /**
+     *
+     * @param privateKey
+     * @param publicKey
+     * @param payload
+     */
+    static verifyPublicRSAKey(privateKey: string, publicKey: string, payload: any): string | StackTraceError;
+    private static traceError;
+}
+
+/**
+ *
+ * @param url
+ * @param user
+ * @param password
+ * @param dbName
+ * @constructor
+ */
+declare function SCheckerMongoDatabaseConnection(url: string, user: string | any, password: string | any, dbName: string | any): Promise<void>;
+
+/**
+ *
+ * @param dbConnection
+ * @param user
+ * @param database
+ * @param dbHost
+ * @param password
+ * @constructor
+ *
+ * Return void
+ */
+declare function SCheckerMySqlDatabaseConnection(dbConnection: mySQL.Connection, user: string, database: string, dbHost: string, password: string): void;
+
+declare function SCheckerPostgresDatabaseConnection(connectionString: any, keepAlive?: boolean | undefined, stream?: any, statement_timeout?: false | number | undefined, ssl?: boolean | ConnectionOptions | undefined, query_timeout?: number | undefined, keepAliveInitialDelayMillis?: number | undefined, idle_in_transaction_session_timeout?: number | undefined, application_name?: string | undefined, connectionTimeoutMillis?: number | undefined, types?: CustomTypesConfig | undefined, options?: string | undefined): Promise<void>;
+
+declare const CLogLevel: {
+    readonly debug: "DEBUG";
+    readonly info: "INFO";
+    readonly warn: "WARN";
+    readonly error: "ERROR";
+};
+
+/** --------------------------------------------------------------------------------------------------------------------------------
+ * Arguments: A connection URL can also take arguments. Here is the same example from above with placeholder
+ * values in uppercase letters for three arguments: mysql://USER:PASSWORD@HOST:PORT/DATABASE?KEY1=VALUE&KEY2=VALUE&KEY3=VALUE
+ *
+ * The following arguments can be used:
+ * connection_limit: Maximum size of the connection pool,
+ * connect_timeout: Maximum number of seconds to wait for a new connection to be opened, 0 means no timeout,
+ * pool_timeout: Maximum number of seconds to wait for a new connection from the pool, 0 means no timeout,
+ * sslcert: Path to the server certificate. Certificate paths are resolved relative to the ./prisma folder,
+ * sslidentity: Path to the PKCS12 certificate,
+ * sslpassword: Password that was used to secure the PKCS12 file,
+ * sslaccept: Configures whether to check for missing values in the certificate. Possible values: accept_invalid_certs, strict,
+ * socket: Points to a directory that contains a socket to be used for the connection,
+ * socket_timeout: Number of seconds to wait until a single query terminates
+ *
+ * So if you want to use argument: write it like this "?sslidentity=client-identity.p12&sslpassword=mypassword&sslcert=rootca.cert"
+ *
+ * ---------------------------------------------------------------------------------------------------------------------------------
+ */
+declare const optionalArgumentConnectionUtil: string;
+
+/**
+ * This class contains methods that allow to decrypt data using public and private keys.
+ */
+declare class RSAKeyDecryption {
+    static privateDecrypt(privateKey: any, decryptData: any): Buffer;
+    static publicDecrypt(publicKey: any, decryptData: any): Buffer;
+}
+
+/**
+ * This class contains methods which allow encrypting data by passing as arguments
+ * the public/private keys and the data to be encrypted.
+ */
+declare class RSAKeyEncryption {
+    static privateEncrypt(privateKey: any, encryptData: any): Buffer;
+    static publicEncrypt(publicKey: any, encryptData: any): Buffer;
+}
+
+declare class YamlParsing {
+    private static logger;
+    static readFile(filePath: string): Promise<void>;
+    /**
+     *
+     * @param content
+     * @private
+     */
+    private static parsing;
+}
+
+/**
+ * Give time like: 6-8-2024 4:30:29
+ */
+declare const dateTimeFormatted: string;
+
+declare class Environment<T> {
+    private readonly config;
+    constructor(config: T);
+    get<K extends keyof T>(key: K): T[K];
+}
+
+declare const MMongoCheckerDatabase: (optionalArgumentConnection: string | any) => Promise<void>;
+
+declare const MMySqlCheckerDatabase: (optionalArgumentConnection: string | any) => void;
+
+declare const MPostgresCheckerDatabase: (optionalArgumentConnection: string | any) => Promise<void>;
+
+declare const loggerConfig: {
+    logLevels: string[];
+    transports: {
+        file: {
+            enabled: boolean;
+            maxSizeMB: number;
+            rotate: boolean;
+        };
+        console: {
+            enabled: boolean;
+        };
+        remote: {
+            enabled: boolean;
+            endpoint: string;
+        };
+    };
+};
+
+declare const CSignRSAKeyComponent: {
+    algorithm: {
+        RSA_MD5: string;
+        RSA_RIPEMD160: string;
+        RSA_SHA1: string;
+        RSA_SHA1_2: string;
+        RSA_SHA224: string;
+        RSA_SHA256: string;
+        RSA_SHA3_224: string;
+        RSA_SHA3_256: string;
+        RSA_SHA3_384: string;
+        RSA_SHA3_512: string;
+        RSA_SHA384: string;
+        RSA_SHA512: string;
+        RSA_SHA512_224: string;
+        RSA_SHA512_256: string;
+        RSA_SM3: string;
+        blake2b512: string;
+        blake2s256: string;
+        id_rsassa_pkcs1_v1_5_with_sha3_224: string;
+        id_rsassa_pkcs1_v1_5_with_sha3_256: string;
+        id_rsassa_pkcs1_v1_5_with_sha3_384: string;
+        id_rsassa_pkcs1_v1_5_with_sha3_512: string;
+        md5: string;
+        md5_sha1: string;
+        md5WithRSAEncryption: string;
+        ripemd: string;
+        ripemd160: string;
+        ripemd160WithRSA: string;
+        rmd160: string;
+        sha1: string;
+        sha1WithRSAEncryption: string;
+        sha224: string;
+        sha224WithRSAEncryption: string;
+        sha256: string;
+        sha256WithRSAEncryption: string;
+        sha3_224: string;
+        sha3_256: string;
+        sha3_384: string;
+        sha3_512: string;
+        sha384: string;
+        sha384WithRSAEncryption: string;
+        sha512: string;
+        sha512_224: string;
+        sha512_224WithRSAEncryption: string;
+        sha512_256: string;
+        sha512_256WithRSAEncryption: string;
+        sha512WithRSAEncryption: string;
+        shake128: string;
+        shake256: string;
+        sm3: string;
+        sm3WithRSAEncryption: string;
+        ssl3_md5: string;
+        ssl3_sha1: string;
+    };
+    keyType: {
+        private: string;
+        public: string;
+    };
+    outputFormat: {
+        base64: string;
+        base64url: string;
+        hex: string;
+        binary: string;
+    };
+    encodingFormat: {
+        ascii: string;
+        utf8: string;
+        utf_8: string;
+        utf16le: string;
+        utf_16le: string;
+        ucs2: string;
+        ucs_2: string;
+        base64: string;
+        base64url: string;
+        latin1: string;
+        binary: string;
+        hex: string;
+    };
+};
+
+declare class Utility {
+    /**
+     *
+     * @param data
+     * @private
+     * Return a string converted in MegaBytes
+     */
+    private formatMemoryUsage;
+    /**
+     * Returns an Object containing a node version, openssl, and v0
+     */
+    getVersions(): {
+        nodeVersion: string;
+        openssl: string;
+        v8: string;
+    };
+    /**
+     * Return an Object containing a Resident Set Size - total memory allocated for the process execution
+     * Total size of the allocated heap
+     * Actual memory used during the execution
+     * Memory usage user
+     * and Memory usage system
+     */
+    getUsageMemory(): {
+        rss: string;
+        heapTotal: string;
+        heapUsed: string;
+        external: string;
+        user: string;
+        system: string;
+    };
+    /**
+     * Return an Object containing a project path and running server time
+     */
+    getProjectInfo(): {
+        projectPath: string;
+        startingTime: string;
+    };
+    /**
+     *
+     * @param filePath
+     * @private
+     */
+    private getEnvFileLoading;
+    /**
+     *
+     * @param development
+     * @param production
+     */
+    getServerRunningMode(development: string, production: string): string;
+    infoServer(nodeVersion: string, startingTime: any, host: string, port: number, rss: string, heapUsed: string, user: string, system: string): void;
+}
+
+declare class PathModuleVerifier {
+    private static log;
+    /**
+     * Verifies if modules at specific paths are loaded.
+     * If any module is not loaded, it throws an error.
+     * @param modulePaths - An array of paths to the modules to verify.
+     */
+    static verifyModulePaths(modulePaths: string[]): void;
+    /**
+     * Checks if a specific module at a given path is loaded in the Node.js require cache.
+     * @param modulePath - The path to the module.
+     * @returns True if the module is loaded, false otherwise.
+     */
+    private static isModulePathLoaded;
+}
+
+declare const translateLanguageLoader: () => void;
+
+interface IBodyParserOptions {
+    type: string;
+}
+
+interface IResponseBodyEndFromResponseEvent {
+    (cb?: () => void): ServerResponse<IncomingMessage>;
+    (chunk: any, cb?: () => void): ServerResponse<IncomingMessage>;
+    (chunk: any, encoding: BufferEncoding, cb?: () => void): ServerResponse<IncomingMessage>;
+}
+
+interface IResponseBodyWriteFromResponseEvent {
+    (chunk: any, callback?: (error: (Error | null | undefined)) => void): boolean;
+    (chunk: any, encoding: BufferEncoding, callback?: (error: (Error | null | undefined)) => void): boolean;
+}
+
+interface IWrappingBodyResponse {
+    (chunk: any, callback?: (error: (Error | null | undefined)) => void): boolean;
+    (chunk: any, encoding: BufferEncoding, callback?: (error: (Error | null | undefined)) => void): boolean;
+}
+
+type TLogLevel = typeof CLogLevel;
+
+type TOriginalWriteEncoding = "ascii" | "utf8" | "utf-8" | "utf16le" | "utf-16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex";
+
+type TParseFunction = (rawBody: string) => any;
+
+/**
+ *
+ * @param options
+ *
+ * Use by this: TJSONBodyParser({ type: 'application/vnd.custom-type' })
+ *
+ * in express, it can be used like this: app.use(TJSONBodyParser({ type: 'application/vnd.custom-type' }));
+ *
+ */
+declare function TJSONBodyParser(options: IBodyParserOptions): void;
+
+/**
+ *
+ * @param options
+ *
+ * Use by this: TRawBodyParser({ type: 'application/vnd.custom-type' })
+ *
+ * in express, it can be used like this: app.use(rawBodyParserType({ type: 'application/vnd.custom-type' }));
+ *
+ */
+declare function TRawBodyParser(options: IBodyParserOptions): void;
+
+/**
+ *
+ * @param options
+ *
+ * Use by this: textBodyParserType({ type: 'text/html' })
+ *
+ * in express, it can be used like this: app.use(textBodyParserType({ type: 'text/html' }));
+ *
+ */
+declare function TTextBodyParser(options: IBodyParserOptions): void;
+
+/**
+ *
+ * @param options
+ *
+ * Use by this: urlencodedBodyParserType({ type: 'application/x-www-form-urlencoded' })
+ *
+ * in express, it can be used like this: app.use(urlencodedBodyParserType({ type: 'application/x-www-form-urlencoded' }));
+ *
+ */
+declare function TUrlencodedBodyParser(options: IBodyParserOptions): void;
+
+export { CLogLevel, CSignRSAKeyComponent, Environment, type IBodyParserOptions, type IResponseBodyEndFromResponseEvent, type IResponseBodyWriteFromResponseEvent, type IWrappingBodyResponse, MMongoCheckerDatabase, MMySqlCheckerDatabase, MPostgresCheckerDatabase, PathModuleVerifier, RSAKeyDecryption, RSAKeyEncryption, SAsymmetricCryptionDataWithPrivateRSAKey, SAsymmetricCryptionDataWithPublicRSAKey, SCheckerMongoDatabaseConnection, SCheckerMySqlDatabaseConnection, SCheckerPostgresDatabaseConnection, TJSONBodyParser, type TLogLevel, type TOriginalWriteEncoding, type TParseFunction, TRawBodyParser, TTextBodyParser, TUrlencodedBodyParser, Utility, YamlParsing, dateTimeFormatted, loggerConfig, optionalArgumentConnectionUtil, translateLanguageLoader };