@dxkit-org/node-js-kit/dist/jwt/index.cjs

Modern TypeScript utility library for Node.js - Network and JWT utilities for server-side JavaScript and TypeScript projects

'use strict';

var jsKit = require('@dxkit-org/js-kit');
var jsonwebtoken = require('jsonwebtoken');

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

var jsonwebtoken__default = /*#__PURE__*/_interopDefault(jsonwebtoken);

// src/jwt/index.ts
async function jwtVerify(input) {
  const { token, secret, options = {} } = input;
  try {
    jsKit.assertNodeEnvironment();
  } catch (error) {
    return {
      status: "error",
      error: {
        code: "environment_error",
        message: "JWT operations are only supported in Node.js environment",
        originalError: error
      }
    };
  }
  return new Promise((resolve) => {
    if (!token || typeof token !== "string") {
      return resolve({
        status: "error",
        error: {
          code: "invalid_token",
          message: "Invalid token: Token must be a non-empty string"
        }
      });
    }
    if (!secret) {
      return resolve({
        status: "error",
        error: {
          code: "invalid_secret",
          message: "Invalid secret: Secret is required for token verification"
        }
      });
    }
    jsonwebtoken__default.default.verify(token, secret, options, (err, decoded) => {
      if (err) {
        return resolve({
          status: "error",
          error: {
            code: "verification_failed",
            message: `JWT verification failed: ${err.message}`,
            originalError: err
          }
        });
      }
      if (!decoded || typeof decoded === "string") {
        return resolve({
          status: "error",
          error: {
            code: "invalid_payload",
            message: "Invalid payload: Expected object payload"
          }
        });
      }
      resolve({
        status: "success",
        data: decoded
      });
    });
  });
}
async function jwtSign(input) {
  const { payload, secret, options = {} } = input;
  try {
    jsKit.assertNodeEnvironment();
  } catch (error) {
    return {
      status: "error",
      error: {
        code: "environment_error",
        message: "JWT operations are only supported in Node.js environment",
        originalError: error
      }
    };
  }
  const { defaultExpiresIn, ...signOptions } = options;
  return new Promise((resolve) => {
    if (!payload || typeof payload !== "object") {
      return resolve({
        status: "error",
        error: {
          code: "invalid_payload",
          message: "Invalid payload: Payload must be an object"
        }
      });
    }
    if (!secret) {
      return resolve({
        status: "error",
        error: {
          code: "invalid_secret",
          message: "Invalid secret: Secret is required for token signing"
        }
      });
    }
    const finalOptions = {
      ...signOptions,
      ...defaultExpiresIn && !signOptions.expiresIn && { expiresIn: defaultExpiresIn }
    };
    jsonwebtoken__default.default.sign(
      payload,
      secret,
      finalOptions,
      (err, token) => {
        if (err) {
          return resolve({
            status: "error",
            error: {
              code: "signing_failed",
              message: `JWT signing failed: ${err.message}`,
              originalError: err
            }
          });
        }
        if (!token) {
          return resolve({
            status: "error",
            error: {
              code: "signing_failed",
              message: "JWT signing failed: No token generated"
            }
          });
        }
        resolve({
          status: "success",
          data: token
        });
      }
    );
  });
}
function jwtDecode(input) {
  const { token, options = {} } = input;
  try {
    if (!token || typeof token !== "string") {
      return {
        status: "error",
        error: {
          code: "invalid_token",
          message: "Invalid token: Token must be a non-empty string"
        }
      };
    }
    const decoded = jsonwebtoken__default.default.decode(token, options);
    if (!decoded) {
      return {
        status: "error",
        error: {
          code: "decode_failed",
          message: "Failed to decode token: Invalid token format"
        }
      };
    }
    return {
      status: "success",
      data: decoded
    };
  } catch (error) {
    return {
      status: "error",
      error: {
        code: "decode_failed",
        message: `Failed to decode token: ${error instanceof Error ? error.message : "Unknown error"}`,
        originalError: error instanceof Error ? error : void 0
      }
    };
  }
}
function jwtIsExpired(input) {
  const { token } = input;
  const decoded = jwtDecode({ token });
  if (decoded.status === "error") {
    return decoded;
  }
  if (!decoded.data.exp) {
    return {
      status: "error",
      error: {
        code: "invalid_payload",
        message: "Token does not contain expiration time (exp claim)"
      }
    };
  }
  const currentTime = Math.floor(Date.now() / 1e3);
  return {
    status: "success",
    data: decoded.data.exp < currentTime
  };
}
function jwtTimeUntilExpiry(input) {
  const { token } = input;
  const decoded = jwtDecode({ token });
  if (decoded.status === "error") {
    return decoded;
  }
  if (!decoded.data.exp) {
    return {
      status: "error",
      error: {
        code: "invalid_payload",
        message: "Token does not contain expiration time (exp claim)"
      }
    };
  }
  const currentTime = Math.floor(Date.now() / 1e3);
  const timeLeft = decoded.data.exp - currentTime;
  return {
    status: "success",
    data: timeLeft > 0 ? timeLeft : 0
  };
}
function isJwtSuccess(result) {
  return result.status === "success";
}
function isJwtError(result) {
  return result.status === "error";
}
function unwrapJwtResult(result) {
  if (result.status === "success") {
    return result.data;
  }
  throw new Error(`JWT ${result.error.code}: ${result.error.message}`);
}
var jwt = {
  /**
   * Verifies a JWT token and returns a result object.
   * Alias for jwtVerify function.
   */
  verify: jwtVerify,
  /**
   * Signs a payload and creates a JWT token, returns a result object.
   * Alias for jwtSign function.
   */
  sign: jwtSign,
  /**
   * Decodes a JWT token without verification, returns a result object.
   * Alias for jwtDecode function.
   */
  decode: jwtDecode,
  /**
   * Checks if a JWT token is expired, returns a result object.
   * Alias for jwtIsExpired function.
   */
  isExpired: jwtIsExpired,
  /**
   * Gets the remaining time until token expiration, returns a result object.
   * Alias for jwtTimeUntilExpiry function.
   */
  timeUntilExpiry: jwtTimeUntilExpiry
};

exports.isJwtError = isJwtError;
exports.isJwtSuccess = isJwtSuccess;
exports.jwt = jwt;
exports.jwtDecode = jwtDecode;
exports.jwtIsExpired = jwtIsExpired;
exports.jwtSign = jwtSign;
exports.jwtTimeUntilExpiry = jwtTimeUntilExpiry;
exports.jwtVerify = jwtVerify;
exports.unwrapJwtResult = unwrapJwtResult;
//# sourceMappingURL=index.cjs.map
//# sourceMappingURL=index.cjs.map