cynx-lib 1.3.41 → 1.3.44

package/utils/utils/duration.cjs

@@ -0,0 +1,119 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var duration_exports = {};
+__export(duration_exports, {
+  default: () => duration_default,
+  formatDurationLabel: () => formatDurationLabel,
+  formatDurationTag: () => formatDurationTag,
+  parseDurationMs: () => parseDurationMs,
+  parseDurationToSeconds: () => parseDurationToSeconds
+});
+module.exports = __toCommonJS(duration_exports);
+function parseDurationToSeconds(input, minSeconds = 60) {
+  if (input === null || input === void 0 || input === "") {
+    return minSeconds;
+  }
+  if (typeof input === "number") {
+    if (isNaN(input) || input <= 0) return minSeconds;
+    return Math.max(minSeconds, Math.round(input));
+  }
+  const str = String(input).trim().toLowerCase();
+  if (/^\d+$/.test(str)) {
+    const num = parseInt(str, 10);
+    return Math.max(minSeconds, num);
+  }
+  const match = str.match(/^(\d+(?:\.\d+)?)\s*(mo|w|d|h|m|s)?$/);
+  if (!match) {
+    return minSeconds;
+  }
+  const val = parseFloat(match[1]);
+  const unit = match[2] || "s";
+  let totalSec = 0;
+  switch (unit) {
+    case "mo":
+      totalSec = val * 30 * 86400;
+      break;
+    case "w":
+      totalSec = val * 7 * 86400;
+      break;
+    case "d":
+      totalSec = val * 86400;
+      break;
+    case "h":
+      totalSec = val * 3600;
+      break;
+    case "m":
+      totalSec = val * 60;
+      break;
+    case "s":
+    default:
+      totalSec = val;
+      break;
+  }
+  const rounded = Math.round(totalSec);
+  return Math.max(minSeconds, rounded);
+}
+function parseDurationMs(val, defaultMs = 30 * 24 * 60 * 60 * 1e3) {
+  if (!val || val === "off" || val === "0" || val === 0) return 0;
+  if (typeof val === "number") return val > 0 ? val : defaultMs;
+  const str = String(val).trim().toLowerCase();
+  const match = str.match(/^(\d+(?:\.\d+)?)\s*([a-z]+)?$/);
+  if (!match) return defaultMs;
+  const num = parseFloat(match[1]);
+  const unit = match[2] || "d";
+  if (unit.startsWith("s")) return Math.round(num * 1e3);
+  if (unit.startsWith("m")) return Math.round(num * 60 * 1e3);
+  if (unit.startsWith("h")) return Math.round(num * 60 * 60 * 1e3);
+  if (unit.startsWith("d")) return Math.round(num * 24 * 60 * 60 * 1e3);
+  if (unit.startsWith("w")) return Math.round(num * 7 * 24 * 60 * 60 * 1e3);
+  return defaultMs;
+}
+function formatDurationTag(seconds) {
+  const s = Number(seconds) || 60;
+  if (s >= 2592e3 && s % 2592e3 === 0) return `${s / 2592e3}mo`;
+  if (s >= 604800 && s % 604800 === 0) return `${s / 604800}w`;
+  if (s >= 86400 && s % 86400 === 0) return `${s / 86400}d`;
+  if (s >= 3600 && s % 3600 === 0) return `${s / 3600}h`;
+  if (s >= 60 && s % 60 === 0) return `${s / 60}m`;
+  return `${s}s`;
+}
+function formatDurationLabel(seconds) {
+  const s = Number(seconds) || 60;
+  if (s === 60) return "1 \u043C\u0438\u043D";
+  if (s === 300) return "5 \u043C\u0438\u043D";
+  if (s === 600) return "10 \u043C\u0438\u043D";
+  if (s === 1800) return "30 \u043C\u0438\u043D";
+  if (s === 3600) return "1 \u0447\u0430\u0441";
+  if (s === 18e3) return "5 \u0447\u0430\u0441\u043E\u0432";
+  if (s === 43200) return "12 \u0447\u0430\u0441\u043E\u0432";
+  if (s === 86400) return "24 \u0447\u0430\u0441\u0430";
+  return formatDurationTag(s);
+}
+var duration_default = {
+  parseDurationToSeconds,
+  parseDurationMs,
+  formatDurationTag,
+  formatDurationLabel
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatDurationLabel,
+  formatDurationTag,
+  parseDurationMs,
+  parseDurationToSeconds
+});

package/utils/utils/oidc.cjs

@@ -0,0 +1,164 @@
+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);
+var oidc_exports = {};
+__export(oidc_exports, {
+  buildAuthorizeUrl: () => buildAuthorizeUrl,
+  consumeState: () => consumeState,
+  decodeIdToken: () => decodeIdToken,
+  default: () => oidc_default,
+  discover: () => discover,
+  exchangeCode: () => exchangeCode,
+  generatePKCE: () => generatePKCE,
+  generateState: () => generateState,
+  getUserInfo: () => getUserInfo,
+  storeVerifier: () => storeVerifier
+});
+module.exports = __toCommonJS(oidc_exports);
+var import_crypto = __toESM(require("crypto"), 1);
+const DEFAULT_SECRET = typeof process !== "undefined" && (process.env?.OIDC_STATE_SECRET || process.env?.JWT_SECRET) || "cynx-oidc-state-secret-salt";
+function generateState(payload = {}, secret = DEFAULT_SECRET) {
+  const data = Buffer.from(JSON.stringify({ ...payload, ts: Date.now() })).toString("base64url");
+  const sig = import_crypto.default.createHmac("sha256", secret).update(data).digest("base64url");
+  return `${data}.${sig}`;
+}
+function consumeState(stateStr, secret = DEFAULT_SECRET, ttlMs = 6e5) {
+  if (!stateStr || typeof stateStr !== "string") return null;
+  const parts = stateStr.split(".");
+  if (parts.length !== 2) return null;
+  const [data, sig] = parts;
+  const expectedSig = import_crypto.default.createHmac("sha256", secret).update(data).digest("base64url");
+  if (sig.length !== expectedSig.length) return null;
+  if (!import_crypto.default.timingSafeEqual(Buffer.from(sig), Buffer.from(expectedSig))) return null;
+  try {
+    const payload = JSON.parse(Buffer.from(data, "base64url").toString("utf8"));
+    if (!payload.ts || Date.now() - payload.ts > ttlMs) return null;
+    return payload;
+  } catch {
+    return null;
+  }
+}
+function generatePKCE() {
+  const codeVerifier = import_crypto.default.randomBytes(32).toString("base64url");
+  const codeChallenge = import_crypto.default.createHash("sha256").update(codeVerifier).digest("base64url");
+  return { codeVerifier, codeChallenge };
+}
+async function discover(issuer, discoveryPath = "/.well-known/openid-configuration") {
+  let base = issuer.replace(/\/+$/, "");
+  let path = discoveryPath || "/.well-known/openid-configuration";
+  if (base.endsWith(path)) {
+    base = base.slice(0, -path.length).replace(/\/+$/, "");
+  }
+  if (!path.startsWith("/")) path = "/" + path;
+  const url = base + path;
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`OIDC Discovery failed: ${res.status} \u2014 ${url}`);
+  return res.json();
+}
+function buildAuthorizeUrl(config, state, codeChallenge) {
+  const params = new URLSearchParams({
+    response_type: "code",
+    client_id: config.clientId,
+    redirect_uri: config.redirectUri,
+    scope: config.scopes || "openid profile email",
+    state
+  });
+  if (config.pkceEnabled !== false && codeChallenge) {
+    params.set("code_challenge", codeChallenge);
+    params.set("code_challenge_method", "S256");
+  }
+  const base = config.issuer.replace(/\/+$/, "");
+  return `${base}/authorize?${params.toString()}`;
+}
+async function exchangeCode(config, code, codeVerifier) {
+  const discoverDoc = await discover(config.issuer, config.discoveryPath);
+  const tokenUrl = discoverDoc.token_endpoint;
+  const body = new URLSearchParams({
+    grant_type: "authorization_code",
+    code,
+    redirect_uri: config.redirectUri,
+    client_id: config.clientId
+  });
+  if (config.clientSecret) {
+    body.set("client_secret", config.clientSecret);
+  }
+  if (config.pkceEnabled !== false && codeVerifier) {
+    body.set("code_verifier", codeVerifier);
+  }
+  const res = await fetch(tokenUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Token exchange failed: ${res.status} ${err}`);
+  }
+  return res.json();
+}
+async function getUserInfo(config, accessToken) {
+  const discoverDoc = await discover(config.issuer, config.discoveryPath);
+  const userinfoUrl = discoverDoc.userinfo_endpoint;
+  if (!userinfoUrl) throw new Error("No userinfo_endpoint in discovery document");
+  const res = await fetch(userinfoUrl, {
+    headers: { Authorization: `Bearer ${accessToken}` }
+  });
+  if (!res.ok) throw new Error(`Userinfo failed: ${res.status}`);
+  return res.json();
+}
+function decodeIdToken(idToken) {
+  if (!idToken || typeof idToken !== "string") throw new Error("Invalid id_token");
+  const parts = idToken.split(".");
+  if (parts.length !== 3) throw new Error("Invalid id_token format (expected 3 parts)");
+  const payload = Buffer.from(parts[1], "base64url").toString("utf8");
+  return JSON.parse(payload);
+}
+function storeVerifier() {
+}
+var oidc_default = {
+  generateState,
+  storeVerifier,
+  consumeState,
+  generatePKCE,
+  discover,
+  buildAuthorizeUrl,
+  exchangeCode,
+  getUserInfo,
+  decodeIdToken
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAuthorizeUrl,
+  consumeState,
+  decodeIdToken,
+  discover,
+  exchangeCode,
+  generatePKCE,
+  generateState,
+  getUserInfo,
+  storeVerifier
+});