@eventcatalog/core 2.44.1 → 2.44.3

package/dist/analytics/analytics.cjs

@@ -37,7 +37,7 @@ var import_axios = __toESM(require("axios"), 1);
 var import_os = __toESM(require("os"), 1);
 
 // package.json
-var version = "2.44.1";
+var version = "2.44.3";
 
 // src/constants.ts
 var VERSION = version;

package/dist/analytics/analytics.js

@@ -1,7 +1,7 @@
 import {
   raiseEvent
-} from "../chunk-AUGREOCT.js";
-import "../chunk-HGLZ22GT.js";
+} from "../chunk-SHFEPDUF.js";
+import "../chunk-EJOD6TNE.js";
 export {
   raiseEvent
 };

package/dist/analytics/log-build.cjs

@@ -106,7 +106,7 @@ var import_axios = __toESM(require("axios"), 1);
 var import_os = __toESM(require("os"), 1);
 
 // package.json
-var version = "2.44.1";
+var version = "2.44.3";
 
 // src/constants.ts
 var VERSION = version;

package/dist/analytics/log-build.js

@@ -1,8 +1,8 @@
 import {
   log_build_default
-} from "../chunk-ECUXDBJ7.js";
-import "../chunk-AUGREOCT.js";
-import "../chunk-HGLZ22GT.js";
+} from "../chunk-CGPQJVQ3.js";
+import "../chunk-SHFEPDUF.js";
+import "../chunk-EJOD6TNE.js";
 import "../chunk-E7TXTI7G.js";
 export {
   log_build_default as default

package/dist/{chunk-ECUXDBJ7.js → chunk-CGPQJVQ3.js}

@@ -1,6 +1,6 @@
 import {
   raiseEvent
-} from "./chunk-AUGREOCT.js";
+} from "./chunk-SHFEPDUF.js";
 import {
   getEventCatalogConfigFile,
   verifyRequiredFieldsAreInCatalogConfigFile

package/dist/{chunk-HGLZ22GT.js → chunk-EJOD6TNE.js}

@@ -1,5 +1,5 @@
 // package.json
-var version = "2.44.1";
+var version = "2.44.3";
 
 // src/constants.ts
 var VERSION = version;

package/dist/{chunk-AUGREOCT.js → chunk-SHFEPDUF.js}

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-HGLZ22GT.js";
+} from "./chunk-EJOD6TNE.js";
 
 // src/analytics/analytics.js
 import axios from "axios";

package/dist/constants.cjs

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

package/dist/constants.js

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

package/dist/eventcatalog.cjs

@@ -157,7 +157,7 @@ var import_axios = __toESM(require("axios"), 1);
 var import_os = __toESM(require("os"), 1);
 
 // package.json
-var version = "2.44.1";
+var version = "2.44.3";
 
 // src/constants.ts
 var VERSION = version;

package/dist/eventcatalog.js

@@ -6,8 +6,8 @@ import {
 } from "./chunk-DCLTVJDP.js";
 import {
   log_build_default
-} from "./chunk-ECUXDBJ7.js";
-import "./chunk-AUGREOCT.js";
+} from "./chunk-CGPQJVQ3.js";
+import "./chunk-SHFEPDUF.js";
 import {
   catalogToAstro,
   checkAndConvertMdToMdx
@@ -15,7 +15,7 @@ import {
 import "./chunk-EXAALOQA.js";
 import {
   VERSION
-} from "./chunk-HGLZ22GT.js";
+} from "./chunk-EJOD6TNE.js";
 import {
   isAuthEnabled,
   isBackstagePluginEnabled,

package/eventcatalog/src/components/MDX/SchemaViewer/SchemaProperty.astro

@@ -13,7 +13,13 @@ const { name, details, isRequired, level, isListItem = false } = Astro.props;
 
 const hasNestedProperties = details.type === 'object' && details.properties && Object.keys(details.properties).length > 0;
 const hasArrayItems = details.type === 'array' && details.items;
-const isCollapsible = hasNestedProperties || (hasArrayItems && details.items.type === 'object' && details.items.properties);
+const hasArrayItemProperties =
+  hasArrayItems &&
+  ((details.items.type === 'object' && details.items.properties) ||
+    details.items.allOf ||
+    details.items.oneOf ||
+    details.items.$ref);
+const isCollapsible = hasNestedProperties || hasArrayItemProperties;
 
 // Using template literal for class calculation remains safe
 const indentationClass = `pl-${level * 3}`;
@@ -48,12 +54,19 @@ const contentId = `prop-${name}-${level}-${Math.random().toString(36).substring(
             {details.type}
             {details.type === 'array' && details.items?.type ? `[${details.items.type}]` : ''}
             {details.format ? `<${details.format}>` : ''}
+            {details._refPath && <span class="text-blue-600 ml-1">→ {details._refName || details._refPath}</span>}
+            {details._refNotFound && <span class="text-red-600 ml-1">❌ ref not found</span>}
           </span>
         </div>
         {isRequired && <span class="text-red-600 text-xs ml-3 flex-shrink-0">required</span>}
       </div>
 
       {details.description && <p class="text-gray-500 text-xs mt-0.5">{details.description}</p>}
+      {
+        details.title && details.title !== details.description && (
+          <p class="text-gray-500 text-xs mt-0.5 italic">Title: {details.title}</p>
+        )
+      }
 
       {/* Reverted arbitrary text size to standard 'text-xs' */}
       <div class="text-xs text-gray-500 mt-0.5 space-y-0">
@@ -78,6 +91,20 @@ const contentId = `prop-${name}-${level}-${Math.random().toString(36).substring(
             </div>
           )
         }
+        {
+          details.minLength !== undefined && (
+            <div>
+              Min length: <code class="bg-gray-100 px-1 rounded text-gray-800 font-thin py-0.5">{details.minLength}</code>
+            </div>
+          )
+        }
+        {
+          details.maxLength !== undefined && (
+            <div>
+              Max length: <code class="bg-gray-100 px-1 rounded text-gray-800 font-thin py-0.5">{details.maxLength}</code>
+            </div>
+          )
+        }
         {
           details.enum && (
             <div>
@@ -110,18 +137,24 @@ const contentId = `prop-${name}-${level}-${Math.random().toString(36).substring(
                 />
               ))}
 
-            {hasArrayItems && details.items.type === 'object' && details.items.properties && (
+            {hasArrayItemProperties && (
               <div class="mt-1 border-l border-dashed border-gray-400 pl-3 ml-1.5">
                 <span class="text-xs italic text-gray-500 block mb-1">Item Details:</span>
-                {Object.entries(details.items.properties).map(([itemPropName, itemPropDetails]) => (
-                  <SchemaProp
-                    name={itemPropName}
-                    details={itemPropDetails}
-                    isRequired={details.items.required?.includes(itemPropName) ?? false}
-                    level={level + 1}
-                    isListItem={true}
-                  />
-                ))}
+                {details.items.properties &&
+                  Object.entries(details.items.properties).map(([itemPropName, itemPropDetails]) => (
+                    <SchemaProp
+                      name={itemPropName}
+                      details={itemPropDetails}
+                      isRequired={details.items.required?.includes(itemPropName) ?? false}
+                      level={level + 1}
+                      isListItem={true}
+                    />
+                  ))}
+                {(details.items.allOf || details.items.oneOf || details.items.$ref) && !details.items.properties && (
+                  <div class="text-xs text-gray-500 mt-1">
+                    Complex array item schema detected. The properties should be processed by the parent SchemaViewer.
+                  </div>
+                )}
               </div>
             )}
           </div>

package/eventcatalog/src/components/MDX/SchemaViewer/SchemaViewer.astro

@@ -14,7 +14,8 @@ interface Props {
 const { id, file, title, maxHeight, schema } = Astro.props;
 
 // Function to merge allOf schemas
-function mergeAllOfSchemas(schema: any) {
+function mergeAllOfSchemas(schemaWithProcessor: any): any {
+  const { processSchema: processor, ...schema } = schemaWithProcessor;
   if (!schema.allOf) return schema;
 
   const mergedSchema: {
@@ -22,63 +23,165 @@ function mergeAllOfSchemas(schema: any) {
     properties: Record<string, any>;
     required: string[];
     description?: string;
+    [key: string]: any;
   } = {
-    type: 'object',
+    type: schema.type || 'object',
     properties: {},
     required: [],
     description: schema.description,
   };
 
+  // Copy base schema properties first (excluding allOf)
+  Object.keys(schema).forEach((key) => {
+    if (key !== 'allOf' && key !== 'properties' && key !== 'required' && key !== 'description') {
+      mergedSchema[key] = schema[key];
+    }
+  });
+
+  // Copy base properties if they exist
+  if (schema.properties) {
+    mergedSchema.properties = { ...schema.properties };
+  }
+  if (schema.required) {
+    mergedSchema.required = [...schema.required];
+  }
+
   schema.allOf.forEach((subSchema: any) => {
-    if (subSchema.properties) {
+    // Recursively process each subSchema in case it has its own allOf, oneOf, or $ref
+    const processedSubSchema = processor ? processor(subSchema) : subSchema;
+
+    if (processedSubSchema.properties) {
       mergedSchema.properties = {
         ...mergedSchema.properties,
-        ...subSchema.properties,
+        ...processedSubSchema.properties,
       };
     }
-    if (subSchema.required) {
-      mergedSchema.required = [...mergedSchema.required, ...subSchema.required];
+    if (processedSubSchema.required) {
+      mergedSchema.required = [...new Set([...mergedSchema.required, ...processedSubSchema.required])];
     }
-    if (subSchema.description && !mergedSchema.description) {
-      mergedSchema.description = subSchema.description;
+    if (processedSubSchema.description && !mergedSchema.description) {
+      mergedSchema.description = processedSubSchema.description;
     }
+
+    // Copy other properties from subSchema
+    Object.keys(processedSubSchema).forEach((key) => {
+      if (key !== 'properties' && key !== 'required' && key !== 'description' && key !== 'type') {
+        if (!mergedSchema[key]) {
+          mergedSchema[key] = processedSubSchema[key];
+        }
+      }
+    });
   });
 
   return mergedSchema;
 }
 
-function processSchema(schema: any) {
+function processSchema(schema: any, rootSchema?: any): any {
+  if (!schema) return schema;
+
+  // Set rootSchema for $ref resolution
+  const root = rootSchema || schema;
+
   // Handle $ref
   if (schema.$ref) {
-    // Only support local refs like "#/definitions/xyz"
     const refPath = schema.$ref;
+    let resolvedSchema = null;
+    let defName = '';
+
+    // Try draft-7 style first: #/definitions/
     if (refPath.startsWith('#/definitions/')) {
-      const defName = refPath.replace('#/definitions/', '');
-      const definitions = schema.definitions;
-      if (definitions && definitions[defName]) {
-        // Recursively process the referenced schema
-        return processSchema(definitions[defName]);
+      defName = refPath.replace('#/definitions/', '');
+      if (root.definitions && root.definitions[defName]) {
+        resolvedSchema = root.definitions[defName];
+      }
+    }
+    // Try 2020-12 style: #/$defs/
+    else if (refPath.startsWith('#/$defs/')) {
+      defName = refPath.replace('#/$defs/', '');
+      if (root.$defs && root.$defs[defName]) {
+        resolvedSchema = root.$defs[defName];
       }
     }
-    // If not found, return as is
-    return schema;
+    // Try other common patterns
+    else if (refPath.startsWith('#/components/schemas/')) {
+      defName = refPath.replace('#/components/schemas/', '');
+      if (root.components && root.components.schemas && root.components.schemas[defName]) {
+        resolvedSchema = root.components.schemas[defName];
+      }
+    }
+
+    if (resolvedSchema) {
+      // Recursively process the referenced schema
+      const processedSchema = processSchema(resolvedSchema, root);
+      // Add reference info to the resolved schema
+      return {
+        ...processedSchema,
+        _refPath: refPath,
+        _refName: defName,
+        _originalRef: schema.$ref,
+      };
+    }
+
+    // If not found, create a placeholder schema showing the reference
+    return {
+      type: 'string',
+      description: `Reference to ${refPath} (definition not found in root schema)`,
+      title: defName || refPath.split('/').pop(),
+      _refPath: refPath,
+      _refName: defName,
+      _refNotFound: true,
+    };
   }
 
   if (schema.allOf) {
-    return mergeAllOfSchemas(schema);
+    return mergeAllOfSchemas({ ...schema, processSchema: (s: any) => processSchema(s, root) });
   }
 
   if (schema.oneOf) {
-    // For oneOf, we'll keep the base properties and handle variants in the UI
+    // Process each oneOf variant and create a combined schema
+    const processedVariants = schema.oneOf.map((variant: any) => {
+      const processedVariant = processSchema(variant, root);
+      return {
+        title: processedVariant.title || variant.title || 'Unnamed Variant',
+        required: processedVariant.required || variant.required || [],
+        properties: processedVariant.properties || {},
+        ...processedVariant,
+      };
+    });
+
+    // Merge all properties from variants for display
+    const allProperties: Record<string, any> = {};
+    processedVariants.forEach((variant) => {
+      if (variant.properties) {
+        Object.assign(allProperties, variant.properties);
+      }
+    });
+
     return {
       ...schema,
-      variants: schema.oneOf.map((variant: any) => ({
-        title: variant.title || 'Unnamed Variant',
-        required: variant.required || [],
-      })),
+      type: schema.type || 'object',
+      properties: {
+        ...(schema.properties || {}),
+        ...allProperties,
+      },
+      variants: processedVariants,
     };
   }
 
+  // Process nested schemas in properties
+  if (schema.properties) {
+    const processedProperties: Record<string, any> = {};
+    Object.entries(schema.properties).forEach(([key, prop]: [string, any]) => {
+      processedProperties[key] = processSchema(prop, root);
+    });
+    schema = { ...schema, properties: processedProperties };
+  }
+
+  // Process array items
+  if (schema.type === 'array' && schema.items) {
+    schema = { ...schema, items: processSchema(schema.items, root) };
+  }
+
   return schema;
 }
 

package/eventcatalog/src/middleware-auth.ts

@@ -33,13 +33,21 @@ interface TypedLocals {
 }
 
 // Wildcard matching utilities
-export function matchesPattern(pattern: string, pathname: string): boolean {
-  const regexPattern = pattern
-    .replace(/\*/g, '[^/]+') // * matches any characters except /
-    .replace(/\*\*/g, '.*'); // ** matches any characters including /
-
-  const regex = new RegExp(`^${regexPattern}$`);
-  return regex.test(pathname);
+export function matchesPattern(pattern: string, path: string): boolean {
+  const escapeRegExp = (str: string) => str.replace(/[-/\\^$+?.()|[\]{}]/g, '\\$&');
+
+  // Convert the pattern to a regular expression
+  const regexStr = pattern
+    .split('/')
+    .map((part) => {
+      if (part === '**') return '.*';
+      if (part === '*') return '[^/]+';
+      return escapeRegExp(part);
+    })
+    .join('/');
+
+  const regex = new RegExp(`^${regexStr}$`);
+  return regex.test(path);
 }
 
 function calculateSpecificity(pattern: string): number {

package/eventcatalog/src/middleware.ts

@@ -21,7 +21,6 @@ try {
     console.log('✅ Loaded custom RBAC middleware');
   }
 } catch (error) {
-  console.log('Error loading custom RBAC middleware:', error);
   // Just silently fail, we don't want to block the app
 }
 

package/package.json

@@ -6,7 +6,7 @@
     "url": "https://github.com/event-catalog/eventcatalog.git"
   },
   "type": "module",
-  "version": "2.44.1",
+  "version": "2.44.3",
   "publishConfig": {
     "access": "public"
   },