@eventcatalog/core 4.12.3 → 5.0.0-beta.1

package/dist/chunk-TQLRG35T.js

@@ -0,0 +1,203 @@
+// src/utils/license-status.ts
+import boxen from "boxen";
+import { isEventCatalogScaleEnabled, isEventCatalogStarterEnabled } from "@eventcatalog/license";
+
+// eventcatalog/src/utils/trial.ts
+var TRIAL_LENGTH_DAYS = 90;
+var LICENSE_FAQ_URL = "https://www.eventcatalog.dev/license-faq";
+var LICENSE_RENEW_URL = "https://eventcatalog.cloud";
+var DAY_IN_MS = 24 * 60 * 60 * 1e3;
+var getTrialStatus = (tsd, now = Date.now()) => {
+  if (typeof tsd !== "number" || !Number.isFinite(tsd) || tsd <= 0) return;
+  const endsAt = tsd + TRIAL_LENGTH_DAYS * DAY_IN_MS;
+  const daysLeft = Math.max(0, Math.ceil((endsAt - now) / DAY_IN_MS));
+  return { daysLeft, ended: daysLeft === 0, endsAt: new Date(endsAt) };
+};
+var LICENSE_REMINDER_DAYS = 30;
+
+// eventcatalog/src/utils/license.ts
+import fs from "fs";
+import path from "path";
+import { clearCache, hasCommercialLicense, verifyOfflineLicense } from "@eventcatalog/license";
+var toDate = (seconds) => typeof seconds === "number" ? new Date(seconds * 1e3) : void 0;
+var getDetails = (claims) => ({
+  org: typeof claims.org === "string" ? claims.org : void 0,
+  licenseId: typeof claims.licenseId === "string" ? claims.licenseId : void 0,
+  issuedAt: toDate(claims.iat)
+});
+var INVALID_REASONS = {
+  LICENSE_FILE_EMPTY: "the file is empty",
+  LICENSE_NOT_YET_VALID: "it is not valid yet",
+  LICENSE_SIGNATURE_INVALID: "its signature is invalid",
+  LICENSE_VALIDATION_FAILED: "it was not issued by EventCatalog"
+};
+var getLicenseFilePath = (projectDirectory) => process.env.EC_LICENSE || path.join(projectDirectory, "license.jwt");
+var readClaims = (licenseFilePath) => {
+  try {
+    const payload = fs.readFileSync(licenseFilePath, "utf8").trim().split(".")[1];
+    return JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+  } catch {
+    return {};
+  }
+};
+var statusCache = /* @__PURE__ */ new Map();
+var getLicensePlan = () => {
+  if (process.env.EVENTCATALOG_SCALE === "true") return "scale";
+  if (process.env.EVENTCATALOG_STARTER === "true") return "starter";
+};
+var getCommercialLicenseStatus = (projectDirectory = process.env.PROJECT_DIR || process.cwd()) => {
+  const licensePath = getLicenseFilePath(projectDirectory);
+  const modifiedAt = fs.statSync(licensePath, { throwIfNoEntry: false })?.mtimeMs;
+  if (modifiedAt === void 0) return Promise.resolve({ state: "none" });
+  const key = `${licensePath}:${modifiedAt}`;
+  if (!statusCache.has(key)) statusCache.set(key, verifyLicense(licensePath));
+  return statusCache.get(key);
+};
+var getLicenseStatus = async (projectDirectory) => {
+  const license = await getCommercialLicenseStatus(projectDirectory);
+  if (license.state === "licensed") return license;
+  const plan = getLicensePlan();
+  return plan ? { state: "plan", plan } : license;
+};
+var verifyLicense = async (licensePath) => {
+  const consoleError = console.error;
+  console.error = () => {
+  };
+  try {
+    clearCache();
+    if (await hasCommercialLicense()) {
+      const entitlements2 = await verifyOfflineLicense({ licensePath });
+      return { state: "licensed", ...getDetails(entitlements2), expiresAt: new Date(entitlements2.exp * 1e3) };
+    }
+    clearCache();
+    const entitlements = await verifyOfflineLicense({ licensePath });
+    if (typeof entitlements.exp !== "number") return { state: "invalid", reason: "it has no expiry date" };
+    return { state: "expired", ...getDetails(entitlements), expiresAt: new Date(entitlements.exp * 1e3) };
+  } catch (error) {
+    if (error?.code === "LICENSE_EXPIRED") {
+      const claims = readClaims(licensePath);
+      return { state: "expired", ...getDetails(claims), expiresAt: toDate(claims.exp) };
+    }
+    return { state: "invalid", reason: INVALID_REASONS[error?.code] || error?.message || String(error) };
+  } finally {
+    console.error = consoleError;
+  }
+};
+
+// src/utils/license-status.ts
+var isPlanEnabled = async (check) => {
+  const consoleError = console.error;
+  console.error = () => {
+  };
+  try {
+    return await check();
+  } catch {
+    return false;
+  } finally {
+    console.error = consoleError;
+  }
+};
+var checkPlanLicense = async () => {
+  if (await isPlanEnabled(isEventCatalogScaleEnabled)) return "scale";
+  if (await isPlanEnabled(isEventCatalogStarterEnabled)) return "starter";
+};
+var getLicenseStatus2 = async (projectDirectory) => {
+  const license = await getCommercialLicenseStatus(projectDirectory);
+  const plan = license.state === "licensed" ? void 0 : await checkPlanLicense();
+  process.env.EVENTCATALOG_SCALE = String(plan === "scale");
+  process.env.EVENTCATALOG_STARTER = String(plan === "starter");
+  return getLicenseStatus(projectDirectory);
+};
+var DAY_IN_MS2 = 24 * 60 * 60 * 1e3;
+var getLicenseType = (license) => {
+  if (license.state === "licensed") return "commercial";
+  if (license.state === "plan") return license.plan;
+  return "trial";
+};
+var getLicenseAnalytics = (license = { state: "none" }, tsd) => ({
+  license: getLicenseType(license),
+  licenseState: license.state === "licensed" || license.state === "plan" ? "valid" : license.state,
+  licenseExpiry: "expiresAt" in license ? license.expiresAt?.getTime() : void 0,
+  trialExpiry: getTrialStatus(tsd)?.endsAt.getTime()
+});
+var formatDate = (date) => date.toLocaleDateString(void 0, { dateStyle: "medium" });
+var formatDays = (days) => `${days} ${days === 1 ? "day" : "days"}`;
+var getTrialLine = (tsd, now) => {
+  const trial = getTrialStatus(tsd, now);
+  if (!trial) return;
+  return trial.ended ? `Your ${TRIAL_LENGTH_DAYS}-day EventCatalog trial ended on ${formatDate(trial.endsAt)}.` : `${formatDays(trial.daysLeft)} left of your ${TRIAL_LENGTH_DAYS}-day EventCatalog trial (ends ${formatDate(trial.endsAt)}).`;
+};
+var getLicenseStatusMessage = (license, tsd, now = Date.now()) => {
+  if (license.state === "licensed") {
+    const daysLeft = Math.max(0, Math.ceil((license.expiresAt.getTime() - now) / DAY_IN_MS2));
+    const licensedTo = license.org ? `Licensed to ${license.org}` : "Licensed";
+    if (daysLeft < LICENSE_REMINDER_DAYS) {
+      return {
+        title: "EventCatalog Commercial License",
+        color: "yellow",
+        text: [
+          licensedTo,
+          `Your license expires in ${formatDays(daysLeft)}, on ${formatDate(license.expiresAt)}.`,
+          `Renew it to keep using EventCatalog commercially: ${LICENSE_RENEW_URL}`
+        ].join("\n")
+      };
+    }
+    return {
+      title: "EventCatalog Commercial License",
+      color: "green",
+      text: `${licensedTo}
+Valid until ${formatDate(license.expiresAt)} (${formatDays(daysLeft)} left)`
+    };
+  }
+  if (license.state === "plan") return;
+  const trialLine = getTrialLine(tsd, now);
+  if (license.state === "none") {
+    if (!trialLine) return;
+    const ended = getTrialStatus(tsd, now)?.ended;
+    return {
+      title: "EventCatalog trial",
+      color: ended ? "yellow" : "green",
+      text: `${trialLine}
+Learn about licensing: ${LICENSE_FAQ_URL}`
+    };
+  }
+  if (license.state === "expired") {
+    const expiredOn = license.expiresAt ? `expired on ${formatDate(license.expiresAt)} (${formatDays(Math.floor((now - license.expiresAt.getTime()) / DAY_IN_MS2))} ago)` : "has expired";
+    return {
+      title: "EventCatalog License Expired",
+      color: "yellow",
+      text: [
+        `Your EventCatalog commercial license${license.org ? ` for ${license.org}` : ""} ${expiredOn}.`,
+        `Renew it to keep using EventCatalog commercially: ${LICENSE_RENEW_URL}`,
+        trialLine,
+        `Learn about licensing: ${LICENSE_FAQ_URL}`
+      ].filter(Boolean).join("\n")
+    };
+  }
+  return {
+    title: "EventCatalog license",
+    color: "yellow",
+    text: [`Your license.jwt could not be verified: ${license.reason}.`, trialLine, `Learn about licensing: ${LICENSE_FAQ_URL}`].filter(Boolean).join("\n")
+  };
+};
+var printLicenseStatus = (license, tsd) => {
+  const message = getLicenseStatusMessage(license, tsd);
+  if (!message) return;
+  console.log(
+    boxen(message.text, {
+      padding: 1,
+      margin: 1,
+      borderStyle: "round",
+      borderColor: message.color,
+      title: message.title,
+      titleAlignment: "center"
+    })
+  );
+};
+
+export {
+  getLicenseStatus2 as getLicenseStatus,
+  getLicenseAnalytics,
+  getLicenseStatusMessage,
+  printLicenseStatus
+};

package/dist/{chunk-M577VUOX.js → chunk-UDS3SYLZ.js}

@@ -1,3 +1,6 @@
+import {
+  getLicenseAnalytics
+} from "./chunk-TQLRG35T.js";
 import {
   countResources,
   hashCatalogContent,
@@ -5,14 +8,16 @@ import {
 } from "./chunk-ZAZHAVKB.js";
 import {
   raiseEvent
-} from "./chunk-ZYTCBNB3.js";
+} from "./chunk-KYJZJLBD.js";
 import {
   getEventCatalogConfigFile,
   verifyRequiredFieldsAreInCatalogConfigFile
 } from "./chunk-RFIXKATC.js";
 
 // src/analytics/log-build.js
+var isMCPEnabled = (configFile) => configFile.output === "server" && (configFile.mcp?.enabled ?? true);
 var getFeatures = async (configFile) => {
+  const mcp = isMCPEnabled(configFile);
   return {
     llmsTxt: configFile.llmsTxt?.enabled || false,
     rss: configFile.rss?.enabled || false,
@@ -20,7 +25,9 @@ var getFeatures = async (configFile) => {
     changelog: configFile.changelog?.enabled || false,
     auth: configFile.auth?.enabled || false,
     environments: Array.isArray(configFile.environments) && configFile.environments.length > 0,
-    output: configFile.output || "static"
+    output: configFile.output || "static",
+    mcp,
+    mcpAuth: mcp && (configFile.mcp?.auth?.enabled ?? false)
   };
 };
 var getDirectoryProvider = (source) => {
@@ -80,21 +87,12 @@ var reportCloudResourceInventory = async (configFile, resourceCounts) => {
     })
   });
 };
-var main = async (projectDir, { isEventCatalogStarterEnabled, isEventCatalogScaleEnabled, isBackstagePluginEnabled, command = "build" }) => {
+var main = async (projectDir, { command = "build", license } = {}) => {
   try {
     await verifyRequiredFieldsAreInCatalogConfigFile(projectDir);
     const configFile = await getEventCatalogConfigFile(projectDir);
     const { cId, tsd, organizationName, generators = [] } = configFile;
-    let generatorNames = generators.length > 0 ? generators.map((generator) => generator[0]) : ["none"];
-    if (isEventCatalogStarterEnabled) {
-      generatorNames.push("@eventcatalog/eventcatalog-starter");
-    }
-    if (isEventCatalogScaleEnabled) {
-      generatorNames.push("@eventcatalog/eventcatalog-scale");
-    }
-    if (isBackstagePluginEnabled) {
-      generatorNames.push("@eventcatalog/backstage-plugin-eventcatalog");
-    }
+    const generatorNames = generators.length > 0 ? generators.map((generator) => generator[0]) : ["none"];
     const features = await getFeatures(configFile);
     const resourceCounts = await countResources(projectDir);
     const contentHash = await hashCatalogContent(projectDir);
@@ -105,11 +103,10 @@ var main = async (projectDir, { isEventCatalogStarterEnabled, isEventCatalogScal
       cId,
       // Trial start date (unix ms) from eventcatalog.config.js
       tsd,
+      // Commercial license or trial, and when each expires (unix ms)
+      ...getLicenseAnalytics(license, tsd),
       // CI redeploys and human-run builds are different signals; tag rather than suppress
       ci: process.env.CI ? "true" : "false",
-      // The commercial plan, separate from the generators list, so telemetry joins cleanly to licensing
-      plan: isEventCatalogScaleEnabled ? "scale" : isEventCatalogStarterEnabled ? "starter" : "none",
-      backstage: isBackstagePluginEnabled ? "true" : "false",
       contentHash,
       generators: generatorNames.toString(),
       features: Object.keys(features).map((feature) => `${feature}:${features[feature]}`).join(","),

package/dist/constants.cjs

@@ -25,7 +25,7 @@ __export(constants_exports, {
 module.exports = __toCommonJS(constants_exports);
 
 // package.json
-var version = "4.12.3";
+var version = "5.0.0-beta.1";
 
 // src/constants.ts
 var VERSION = version;

package/dist/constants.js

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-HPC6KUDQ.js";
+} from "./chunk-S2QGT7ZF.js";
 export {
   VERSION
 };