kaven-utils/src/GeneratedCertificateFiles.js

Utils for Node.js.

/********************************************************************
 * @author:      Kaven
 * @email:       kaven@wuwenkai.com
 * @website:     http://blog.kaven.xyz
 * @file:        [Kaven-Utils] /src/GeneratedCertificateFiles.ts
 * @create:      2022-04-21 17:04:55.396
 * @modify:      2023-12-07 10:59:05.589
 * @version:     5.4.0
 * @times:       14
 * @lines:       163
 * @copyright:   Copyright © 2022-2023 Kaven. All Rights Reserved.
 * @description: [description]
 * @license:     [license]
 ********************************************************************/
import { dirname, isAbsolute, relative, resolve } from "node:path";
import { GeneratedFile } from "./GeneratedFile.js";
import { IsPathExistSync, LoadJsonFile, SaveStringToFile } from "./KavenUtility.FileSystem.js";
import { InternalLogger } from "./KavenUtility.Internal.js";
export class GeneratedCertificateFiles {
    constructor(options) {
        if (options.caKey) {
            this.CaKey = new GeneratedFile(options.caKey);
        }
        if (options.caCert) {
            this.CaCert = new GeneratedFile(options.caCert);
        }
        if (options.serverKey) {
            this.ServerKey = new GeneratedFile(options.serverKey);
        }
        if (options.serverReq) {
            this.ServerReq = new GeneratedFile(options.serverReq);
        }
        if (options.serverCert) {
            this.ServerCert = new GeneratedFile(options.serverCert);
        }
        if (options.clientKey) {
            this.ClientKey = new GeneratedFile(options.clientKey);
        }
        if (options.clientReq) {
            this.ClientReq = new GeneratedFile(options.clientReq);
        }
        if (options.clientCert) {
            this.ClientCert = new GeneratedFile(options.clientCert);
        }
    }
    CaKey;
    CaCert;
    ServerKey;
    ServerReq;
    ServerCert;
    ClientKey;
    ClientReq;
    ClientCert;
    async Delete() {
        await Promise.all([
            this.CaKey?.Delete(),
            this.CaCert?.Delete(),
            this.ServerKey?.Delete(),
            this.ServerReq?.Delete(),
            this.ServerCert?.Delete(),
            this.ClientKey?.Delete(),
            this.ClientReq?.Delete(),
            this.ClientCert?.Delete(),
        ]);
    }
    async Save(file) {
        file = resolve(file);
        const dir = dirname(file);
        const getPath = (path) => {
            if (!path) {
                return "";
            }
            return relative(dir, resolve(path));
        };
        const json = {
            caKey: getPath(this.CaKey?.Path),
            caCert: getPath(this.CaCert?.Path),
            serverKey: getPath(this.ServerKey?.Path),
            serverReq: getPath(this.ServerReq?.Path),
            serverCert: getPath(this.ServerCert?.Path),
            clientKey: getPath(this.ClientKey?.Path),
            clientReq: getPath(this.ClientReq?.Path),
            clientCert: getPath(this.ClientCert?.Path),
        };
        await SaveStringToFile(JSON.stringify(json, undefined, 2), file);
    }
    static async Load(file) {
        try {
            if (IsPathExistSync(file)) {
                const json = await LoadJsonFile(file);
                const dir = dirname(file);
                if (json.caKey) {
                    if (!isAbsolute(json.caKey)) {
                        json.caKey = resolve(dir, json.caKey);
                    }
                }
                if (json.caCert) {
                    if (!isAbsolute(json.caCert)) {
                        json.caCert = resolve(dir, json.caCert);
                    }
                }
                if (json.serverKey) {
                    if (!isAbsolute(json.serverKey)) {
                        json.serverKey = resolve(dir, json.serverKey);
                    }
                }
                if (json.serverReq) {
                    if (!isAbsolute(json.serverReq)) {
                        json.serverReq = resolve(dir, json.serverReq);
                    }
                }
                if (json.serverCert) {
                    if (!isAbsolute(json.serverCert)) {
                        json.serverCert = resolve(dir, json.serverCert);
                    }
                }
                if (json.clientKey) {
                    if (!isAbsolute(json.clientKey)) {
                        json.clientKey = resolve(dir, json.clientKey);
                    }
                }
                if (json.clientReq) {
                    if (!isAbsolute(json.clientReq)) {
                        json.clientReq = resolve(dir, json.clientReq);
                    }
                }
                if (json.clientCert) {
                    if (!isAbsolute(json.clientCert)) {
                        json.clientCert = resolve(dir, json.clientCert);
                    }
                }
                return new GeneratedCertificateFiles(json);
            }
        }
        catch (ex) {
            InternalLogger()?.Error(ex);
        }
        return undefined;
    }
}