@intrasoft/auth-core/dist/index.js

A robust and customizable authentication package for Node.js applications, providing JWT-based authentication and token management

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  createToken: () => createToken,
  decodeJwt: () => decodeJwt,
  refreshToken: () => refreshToken
});
module.exports = __toCommonJS(index_exports);

// src/tokens.ts
var jwt = __toESM(require("jsonwebtoken"));

// src/config.ts
function validateConfig(config) {
  if (!config.secretKey) {
    throw new Error("Missing secretKey in configuration");
  }
  if (isNaN(config.accessLifetime)) {
    throw new Error("Missing or invalid accessLifetime in configuration");
  }
  if (config.accessLifetime && isNaN(config.refreshLifetime)) {
    throw new Error("Invalid refreshLifetime in configuration");
  }
}
var CACHED_CONFIG = void 0;
function getConfig() {
  if (CACHED_CONFIG) return CACHED_CONFIG;
  const config = {
    secretKey: process.env.INTRASOFT_SECRET_KEY,
    accessLifetime: parseInt(process.env.INTRASOFT_ACCESS_TOKEN_LIFETIME),
    refreshLifetime: parseInt(process.env.INTRASOFT_REFRESH_TOKEN_LIFETIME)
  };
  validateConfig(config);
  CACHED_CONFIG = config;
  return config;
}

// src/tokens.ts
async function createToken(payload) {
  const validTypes = ["object"];
  if (!payload || !validTypes.includes(typeof payload)) {
    throw new Error("Invalid payload type");
  }
  const config = getConfig();
  const _payload = new Object({ payload });
  return generateTokens(_payload, false, config);
}
async function refreshToken(refreshToken2) {
  try {
    const config = getConfig();
    const verifiedToken = jwt.verify(
      refreshToken2,
      config.secretKey
    );
    return generateTokens(verifiedToken.payload, true, config);
  } catch (error) {
    throw new Error("Invalid refresh token");
  }
}
async function decodeJwt(token) {
  const config = getConfig();
  const payload = jwt.verify(token, config.secretKey);
  return payload;
}
function generateTokens(payload, _r, config) {
  const _payload = new Object({ _r, payload });
  const access = jwt.sign(_payload, config.secretKey, {
    expiresIn: config.accessLifetime
  });
  const token = {
    access
  };
  if (config.refreshLifetime) {
    token.refresh = jwt.sign(_payload, config.secretKey, {
      expiresIn: config.refreshLifetime
    });
  }
  return token;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  createToken,
  decodeJwt,
  refreshToken
});