generate-certs/dist/index.js

🗝️ Effortless HTTPS Certificate Generation for Local Development

'use strict';

var fs = require('fs');
var path = require('path');
var forge = require('node-forge');

function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }

var fs__default = /*#__PURE__*/_interopDefault(fs);
var path__default = /*#__PURE__*/_interopDefault(path);
var forge__default = /*#__PURE__*/_interopDefault(forge);

// src/index.ts
function $generateCerts(certificatesPath) {
  if (fs__default.default.existsSync(certificatesPath)) fs__default.default.rmSync(certificatesPath, { recursive: true });
  fs__default.default.mkdirSync(certificatesPath, { recursive: true });
  const keys = forge__default.default.pki.rsa.generateKeyPair(2048);
  const privateKey = forge__default.default.pki.privateKeyToPem(keys.privateKey);
  fs__default.default.writeFileSync(path__default.default.join(certificatesPath, "key.pem"), privateKey);
  const cert = forge__default.default.pki.createCertificate();
  cert.publicKey = keys.publicKey;
  cert.serialNumber = "01";
  cert.validity.notBefore = /* @__PURE__ */ new Date();
  cert.validity.notAfter = /* @__PURE__ */ new Date();
  cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 1);
  const attrs = [{ name: "commonName", value: "localhost" }];
  cert.setSubject(attrs);
  cert.setIssuer(attrs);
  cert.sign(keys.privateKey, forge__default.default.md.sha256.create());
  const certPem = forge__default.default.pki.certificateToPem(cert);
  fs__default.default.writeFileSync(path__default.default.join(certificatesPath, "cert.pem"), certPem);
}

// src/index.ts
function generateCerts({ certsPath, activateLogs = true }) {
  const certs = $checkForCerts({ certsPath, activateLogs });
  if (certs) return certs;
  try {
    $generateCerts(certsPath);
    if (activateLogs) {
      console.log("\u{1F510} Certificates for HTTPS have been generated successfully!");
      console.log(`\u{1F6D1} Please visit the URL, click on 'Advanced' -> 'Proceed to localhost(unsafe)' to continue.`);
    }
    return { key: $readFile(certsPath, "key.pem"), cert: $readFile(certsPath, "cert.pem") };
  } catch (err) {
    throw new Error(`\u274C Error generating certificates: ${err instanceof Error ? err.message : "Unknown error"}`);
  }
}
function $checkForCerts({ certsPath, activateLogs: log = true }) {
  try {
    if ($isFileExists(certsPath, "key.pem") && $isFileExists(certsPath, "cert.pem")) {
      if (log) console.log("\u{1F50D} Found existing certificates for HTTPS.");
      return { key: $readFile(certsPath, "key.pem"), cert: $readFile(certsPath, "cert.pem") };
    }
  } catch (err) {
    throw new Error(
      `\u274C Error checking for existing certificates: ${err instanceof Error ? err.message : "Unknown error"}`
    );
  }
}
function $isFileExists(dir, fileName) {
  return fs__default.default.existsSync(path__default.default.join(dir, fileName));
}
function $readFile(dir, fileName) {
  if (!$isFileExists(dir, fileName)) throw new Error(`"${fileName}" not found.`);
  return fs__default.default.readFileSync(path__default.default.join(dir, fileName), "utf8");
}

exports.$isFileExists = $isFileExists;
exports.$readFile = $readFile;
exports.generateCerts = generateCerts;
//# sourceMappingURL=index.js.map
//# sourceMappingURL=index.js.map