@living-architecture/riviere-cli 0.9.3 → 0.9.5

package/dist/bin.js

@@ -6886,6 +6886,10 @@ var BuildValidationError = class extends Error {
   }
 };
 
+// ../riviere-schema/dist/schema.js
+var EVENT_NAME_FIELD = "eventName";
+var SUBSCRIBED_EVENTS_FIELD = "subscribedEvents";
+
 // ../riviere-schema/dist/validation.js
 var import_ajv = __toESM(require_ajv(), 1);
 var import_ajv_formats = __toESM(require_dist(), 1);
@@ -25532,7 +25536,6 @@ var COMPONENT_TYPES = [
   "domainOp",
   "event",
   "eventHandler",
-  "eventPublisher",
   "ui"
 ];
 function extractComponents(project, sourceFilePaths, config2, globMatcher, configDir) {
@@ -25691,7 +25694,6 @@ function resolveModule(moduleConfig, loader) {
     domainOp: requireRule(moduleConfig.domainOp, "domainOp", moduleConfig.name),
     event: requireRule(moduleConfig.event, "event", moduleConfig.name),
     eventHandler: requireRule(moduleConfig.eventHandler, "eventHandler", moduleConfig.name),
-    eventPublisher: requireRule(moduleConfig.eventPublisher, "eventPublisher", moduleConfig.name),
     ui: requireRule(moduleConfig.ui, "ui", moduleConfig.name),
     ...moduleConfig.customTypes !== void 0 && { customTypes: moduleConfig.customTypes }
   };
@@ -25711,7 +25713,6 @@ function resolveModuleWithExtends(moduleConfig, extendsSource, loader) {
     domainOp: moduleConfig.domainOp ?? baseModule.domainOp,
     event: moduleConfig.event ?? baseModule.event,
     eventHandler: moduleConfig.eventHandler ?? baseModule.eventHandler,
-    eventPublisher: moduleConfig.eventPublisher ?? baseModule.eventPublisher,
     ui: moduleConfig.ui ?? baseModule.ui,
     ...mergedCustomTypes !== void 0 && { customTypes: mergedCustomTypes }
   };
@@ -28171,90 +28172,104 @@ function traceNonComponent(project, componentIndex, source, typeName, calledMeth
   }
 }
 
-// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/async-detection/detect-publish-connections.js
-function detectPublishConnections(components, options) {
-  const publishers = components.filter((c) => c.type === "eventPublisher");
+// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/async-detection/async-detection-types.js
+function toSourceLocation(component, repository) {
+  return {
+    repository,
+    filePath: component.location.file,
+    lineNumber: component.location.line
+  };
+}
+
+// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/async-detection/detect-event-publisher-connections.js
+function detectEventPublisherConnections(components, eventPublishers, options) {
+  if (eventPublishers.length === 0) {
+    return [];
+  }
   const events = components.filter((c) => c.type === "event");
-  const repository = options.repository;
-  return publishers.flatMap((publisher) => {
-    const publishedEventType = publisher.metadata["publishedEventType"];
-    const sourceLocation = {
-      repository,
-      filePath: publisher.location.file,
-      lineNumber: publisher.location.line
-    };
-    if (typeof publishedEventType !== "string") {
-      return [handleMissingMetadata(publisher, options, sourceLocation)];
-    }
-    return resolvePublishTarget(publisher, publishedEventType, events, options, sourceLocation);
+  return eventPublishers.flatMap((publisherConfig) => {
+    const { fromType, metadataKey } = publisherConfig;
+    const publishers = components.filter((c) => c.type === fromType);
+    return publishers.flatMap((publisher) => {
+      const publishedEventType = publisher.metadata[metadataKey];
+      if (Array.isArray(publishedEventType)) {
+        const validTypes = publishedEventType.filter((t) => typeof t === "string" && t.trim() !== "");
+        if (validTypes.length === 0) {
+          return [handleMissingMetadata(publisher, metadataKey, options)];
+        }
+        return validTypes.flatMap((t) => resolvePublishTarget(publisher, t, events, options));
+      }
+      if (typeof publishedEventType !== "string" || publishedEventType.trim() === "") {
+        return [handleMissingMetadata(publisher, metadataKey, options)];
+      }
+      return resolvePublishTarget(publisher, publishedEventType, events, options);
+    });
   });
 }
-function handleMissingMetadata(publisher, options, sourceLocation) {
+function handleMissingMetadata(publisher, metadataKey, options) {
   if (options.strict) {
     throw new ConnectionDetectionError({
-      file: sourceLocation.filePath,
-      line: sourceLocation.lineNumber,
+      file: publisher.location.file,
+      line: publisher.location.line,
       typeName: publisher.name,
-      reason: 'eventPublisher is missing required "publishedEventType" metadata'
+      reason: `published event type in "${metadataKey}" metadata is missing or invalid`
     });
   }
   return {
     source: componentIdentity(publisher),
     target: "_unresolved",
     type: "async",
-    sourceLocation,
-    _uncertain: `eventPublisher "${publisher.name}" is missing required "publishedEventType" metadata`
+    sourceLocation: toSourceLocation(publisher, options.repository),
+    _uncertain: `event publisher "${publisher.name}" is missing required "${metadataKey}" metadata`
   };
 }
-function resolvePublishTarget(publisher, publishedEventType, events, options, sourceLocation) {
-  const matchingEvents = events.filter((e) => e.metadata["eventName"] === publishedEventType);
+function resolvePublishTarget(publisher, publishedEventType, events, options) {
+  const matchingEvents = events.filter((e) => e.metadata[EVENT_NAME_FIELD] === publishedEventType);
   if (matchingEvents.length === 0) {
-    return [handleNoMatch(publisher, publishedEventType, options, sourceLocation)];
+    return [handleNoMatch(publisher, publishedEventType, options)];
   }
   if (matchingEvents.length > 1) {
-    return [
-      handleAmbiguousMatch(publisher, publishedEventType, matchingEvents.length, options, sourceLocation)
-    ];
+    return [handleAmbiguousMatch(publisher, publishedEventType, matchingEvents.length, options)];
   }
   return matchingEvents.map((event) => ({
     source: componentIdentity(publisher),
     target: componentIdentity(event),
     type: "async",
-    sourceLocation
+    sourceLocation: toSourceLocation(publisher, options.repository)
   }));
 }
-function handleAmbiguousMatch(publisher, publishedEventType, matchCount, options, sourceLocation) {
+function handleAmbiguousMatch(publisher, publishedEventType, matchCount, options) {
   if (options.strict) {
     throw new ConnectionDetectionError({
-      file: sourceLocation.filePath,
-      line: sourceLocation.lineNumber,
+      file: publisher.location.file,
+      line: publisher.location.line,
       typeName: publisher.name,
-      reason: `publishedEventType "${publishedEventType}" matches ${matchCount} Event components (ambiguous)`
+      reason: `published event "${publishedEventType}" matches ${matchCount} Event components (ambiguous)`
     });
   }
   return {
     source: componentIdentity(publisher),
     target: "_unresolved",
     type: "async",
-    sourceLocation,
-    _uncertain: `ambiguous: ${matchCount} events match publishedEventType: ${publishedEventType}`
+    sourceLocation: toSourceLocation(publisher, options.repository),
+    _uncertain: `ambiguous: ${matchCount} events match published event type: ${publishedEventType}`
   };
 }
-function handleNoMatch(publisher, publishedEventType, options, sourceLocation) {
+function handleNoMatch(publisher, publishedEventType, options) {
   if (options.strict) {
     throw new ConnectionDetectionError({
-      file: sourceLocation.filePath,
-      line: sourceLocation.lineNumber,
+      file: publisher.location.file,
+      line: publisher.location.line,
       typeName: publisher.name,
-      reason: `publishedEventType "${publishedEventType}" does not match any Event component`
+      reason: `published event "${publishedEventType}" does not match any Event component`
     });
   }
   return {
     source: componentIdentity(publisher),
     target: "_unresolved",
     type: "async",
-    sourceLocation,
-    _uncertain: `no event found for publishedEventType: ${publishedEventType}`
+    sourceLocation: toSourceLocation(publisher, options.repository),
+    _uncertain: `no event found for published event type: ${publishedEventType}`
   };
 }
 
@@ -28265,15 +28280,8 @@ function detectSubscribeConnections(components, options) {
   const repository = options.repository;
   return eventHandlers.flatMap((handler) => getSubscribedEvents(handler).flatMap((eventName) => resolveSubscription(handler, eventName, events, options, repository)));
 }
-function toSourceLocation(component, repository) {
-  return {
-    repository,
-    filePath: component.location.file,
-    lineNumber: component.location.line
-  };
-}
 function resolveSubscription(handler, eventName, events, options, repository) {
-  const matchingEvents = events.filter((e) => e.metadata["eventName"] === eventName);
+  const matchingEvents = events.filter((e) => e.metadata[EVENT_NAME_FIELD] === eventName);
   if (matchingEvents.length === 0) {
     return [handleNoMatch2(handler, eventName, options, repository)];
   }
@@ -28322,7 +28330,7 @@ function handleNoMatch2(handler, eventName, options, repository) {
   };
 }
 function getSubscribedEvents(handler) {
-  const raw = handler.metadata["subscribedEvents"];
+  const raw = handler.metadata[SUBSCRIBED_EVENTS_FIELD];
   if (!Array.isArray(raw)) {
     return [];
   }
@@ -28591,15 +28599,13 @@ function detectPerModuleConnections(project, components, options, globMatcher) {
 function detectCrossModuleConnections(allComponents, options) {
   const strict = options.allowIncomplete !== true;
   const repository = options.repository;
-  const asyncStart = performance.now();
-  const publishLinks = detectPublishConnections(allComponents, {
-    strict,
-    repository
-  });
-  const subscribeLinks = detectSubscribeConnections(allComponents, {
+  const asyncOptions = {
     strict,
     repository
-  });
+  };
+  const asyncStart = performance.now();
+  const publishLinks = detectEventPublisherConnections(allComponents, options.eventPublishers ?? [], asyncOptions);
+  const subscribeLinks = detectSubscribeConnections(allComponents, asyncOptions);
   const asyncDetectionMs = performance.now() - asyncStart;
   return {
     links: [...publishLinks, ...subscribeLinks],
@@ -28638,7 +28644,6 @@ function getBuiltInRule(module, componentType) {
     domainOp: module.domainOp,
     event: module.event,
     eventHandler: module.eventHandler,
-    eventPublisher: module.eventPublisher,
     ui: module.ui
   };
   const rule = ruleMap[componentType];
@@ -28654,7 +28659,6 @@ function findDetectionRule(module, componentType) {
     "domainOp",
     "event",
     "eventHandler",
-    "eventPublisher",
     "ui"
   ];
   if (builtInTypes.includes(componentType)) {
@@ -28705,10 +28709,7 @@ function evaluateClassRule(rule, classDecl) {
   if ("fromClassName" in rule) {
     return evaluateFromClassNameRule(rule, classDecl);
   }
-  if (!("fromProperty" in rule)) {
-    throw new ExtractionError("Unsupported extraction rule type for class-based component", classDecl.getSourceFile().getFilePath(), classDecl.getStartLineNumber());
-  }
-  return evaluateFromPropertyRule(rule, classDecl);
+  throw new ExtractionError("Unsupported extraction rule type for class-based component", classDecl.getSourceFile().getFilePath(), classDecl.getStartLineNumber());
 }
 function evaluateRule2(rule, draft, project) {
   if ("literal" in rule) {
@@ -28725,6 +28726,10 @@ function evaluateRule2(rule, draft, project) {
     const classDecl2 = findContainingClass(project, draft);
     return evaluateFromGenericArgRule(rule, classDecl2);
   }
+  if ("fromProperty" in rule) {
+    const classDecl2 = findContainingClass(project, draft);
+    return evaluateFromPropertyRule(rule, classDecl2);
+  }
   if ("fromParameterType" in rule) {
     const methodDecl = findMethodAtLine(project, draft);
     const params = methodDecl.getParameters();
@@ -28905,10 +28910,6 @@ var extraction_config_schema_default = {
           $ref: "#/$defs/componentRule",
           description: "Detection rule for EventHandler components"
         },
-        eventPublisher: {
-          $ref: "#/$defs/componentRule",
-          description: "Detection rule for EventPublisher components"
-        },
         ui: {
           $ref: "#/$defs/componentRule",
           description: "Detection rule for UI components"
@@ -28921,7 +28922,7 @@ var extraction_config_schema_default = {
           }
         },
         connections: {
-          $ref: "#/$defs/connectionsConfig",
+          $ref: "#/$defs/moduleConnectionsConfig",
           description: "Module-level connection detection patterns additive to global"
         }
       },
@@ -28931,7 +28932,7 @@ var extraction_config_schema_default = {
         }
       },
       then: {
-        required: ["api", "useCase", "domainOp", "event", "eventHandler", "eventPublisher", "ui"]
+        required: ["api", "useCase", "domainOp", "event", "eventHandler", "ui"]
       }
     },
     componentRule: {
@@ -29425,7 +29426,6 @@ var extraction_config_schema_default = {
     connectionsConfig: {
       type: "object",
       description: "Connection detection configuration with pattern definitions",
-      required: ["patterns"],
       additionalProperties: false,
       properties: {
         patterns: {
@@ -29435,6 +29435,47 @@ var extraction_config_schema_default = {
           items: {
             $ref: "#/$defs/connectionPattern"
           }
+        },
+        eventPublishers: {
+          type: "array",
+          description: "Declares which custom component types publish events and how to detect the connections",
+          minItems: 1,
+          items: {
+            $ref: "#/$defs/eventPublisherConfig"
+          }
+        }
+      }
+    },
+    moduleConnectionsConfig: {
+      type: "object",
+      description: "Module-level connection detection configuration (patterns only \u2014 eventPublishers is top-level only)",
+      additionalProperties: false,
+      properties: {
+        patterns: {
+          type: "array",
+          description: "Connection detection patterns",
+          minItems: 1,
+          items: {
+            $ref: "#/$defs/connectionPattern"
+          }
+        }
+      }
+    },
+    eventPublisherConfig: {
+      type: "object",
+      description: "Declares a custom component type as an event publisher",
+      required: ["fromType", "metadataKey"],
+      additionalProperties: false,
+      properties: {
+        fromType: {
+          type: "string",
+          description: "The custom component type name \u2014 must be defined in customTypes in at least one module",
+          minLength: 1
+        },
+        metadataKey: {
+          type: "string",
+          description: "The metadata key on this component type that holds the published event type name",
+          minLength: 1
         }
       }
     },
@@ -29570,7 +29611,6 @@ var REQUIRED_FIELDS = {
   api: ["apiType"],
   event: ["eventName"],
   eventHandler: ["subscribedEvents"],
-  eventPublisher: [],
   domainOp: ["operationName"],
   ui: ["route"],
   useCase: []
@@ -29581,7 +29621,6 @@ var COMPONENT_TYPES2 = [
   "domainOp",
   "event",
   "eventHandler",
-  "eventPublisher",
   "ui"
 ];
 var ajv2 = new import_ajv2.default({ allErrors: true });
@@ -29660,6 +29699,54 @@ function validateAllExtractionRules(config2) {
     return validateModuleExtractionRules(module, index);
   });
 }
+function collectCustomTypeExtractedFields(config2) {
+  const fieldsByType = /* @__PURE__ */ new Map();
+  for (const module of config2.modules) {
+    if ("$ref" in module || module.customTypes === void 0) {
+      continue;
+    }
+    for (const [typeName, rule] of Object.entries(module.customTypes)) {
+      const existing = fieldsByType.get(typeName) ?? /* @__PURE__ */ new Set();
+      for (const key of Object.keys(rule.extract ?? {})) {
+        existing.add(key);
+      }
+      fieldsByType.set(typeName, existing);
+    }
+  }
+  return fieldsByType;
+}
+function validateEventPublishers(connections, customTypeFields) {
+  if (connections.eventPublishers === void 0) {
+    return [];
+  }
+  return connections.eventPublishers.flatMap((publisher, index) => {
+    const extractedFields = customTypeFields.get(publisher.fromType);
+    if (extractedFields === void 0) {
+      return [
+        {
+          path: `/connections/eventPublishers/${index}/fromType`,
+          message: `"${publisher.fromType}" is not defined as a customType in any module. Add a customType named "${publisher.fromType}" to at least one module.`
+        }
+      ];
+    }
+    if (!extractedFields.has(publisher.metadataKey)) {
+      return [
+        {
+          path: `/connections/eventPublishers/${index}/fromType`,
+          message: `customType "${publisher.fromType}" does not extract "${publisher.metadataKey}". Add extract["${publisher.metadataKey}"] to that custom type.`
+        }
+      ];
+    }
+    return [];
+  });
+}
+function validateConnectionsConfig(config2) {
+  if (config2.connections === void 0) {
+    return [];
+  }
+  const customTypeFields = collectCustomTypeExtractedFields(config2);
+  return validateEventPublishers(config2.connections, customTypeFields);
+}
 function validateExtractionConfigSchema(data) {
   const schemaValid = validate2(data) === true;
   if (!schemaValid) {
@@ -29677,7 +29764,7 @@ function validateExtractionConfig(data) {
   if (!isValidExtractionConfig(data)) {
     return validateExtractionConfigSchema(data);
   }
-  const semanticErrors = validateAllExtractionRules(data);
+  const semanticErrors = [...validateAllExtractionRules(data), ...validateConnectionsConfig(data)];
   if (semanticErrors.length > 0) {
     return {
       valid: false,
@@ -29693,10 +29780,10 @@ function formatValidationErrors2(errors) {
   return formatValidationErrorsInternal2(errors);
 }
 function parseExtractionConfig(data) {
-  if (isValidExtractionConfig(data)) {
+  const result = validateExtractionConfig(data);
+  if (result.valid && isValidExtractionConfig(data)) {
     return data;
   }
-  const result = validateExtractionConfig(data);
   throw new ExtractionConfigValidationError(result.errors);
 }
 
@@ -30049,7 +30136,8 @@ var ExtractionProject = class {
     }
     const crossResult = detectCrossModuleConnections(enrichedComponents, {
       allowIncomplete,
-      repository: this.repositoryName
+      repository: this.repositoryName,
+      eventPublishers: this.resolvedConfig.connections?.eventPublishers
     });
     links.push(...crossResult.links);
     timings.push({
@@ -30355,7 +30443,6 @@ ${formatValidationErrors2(validationResult.errors)}`
       domainOp: parsed.domainOp ?? NOT_USED,
       event: parsed.event ?? NOT_USED,
       eventHandler: parsed.eventHandler ?? NOT_USED,
-      eventPublisher: parsed.eventPublisher ?? NOT_USED,
       ui: parsed.ui ?? NOT_USED
     };
   }
@@ -31120,7 +31207,7 @@ function parsePackageJson(pkg) {
 }
 function loadPackageJson() {
   if (true) {
-    return { version: "0.9.2" };
+    return { version: "0.9.4" };
   }
   const require2 = createRequire2(import.meta.url);
   return parsePackageJson(require2("../../package.json"));
@@ -31214,7 +31301,6 @@ program.parseAsync().catch(handleGlobalError);
 /* istanbul ignore else -- @preserve: false branch is unreachable; FindTarget is exhaustive */
 /* istanbul ignore next -- @preserve: unreachable with valid FindTarget type; defensive fallback */
 /* v8 ignore next -- @preserve: getExtends() !== undefined guarantees getBaseClass() returns a value */
-/* istanbul ignore next -- @preserve: only fromProperty reaches here; defensive guard */
 /* istanbul ignore next -- @preserve: catch always receives Error instances from ExtractionError */
 /* v8 ignore start -- @preserve: default executor delegates to execFileSync; tested via CLI integration */
 /* v8 ignore next -- @preserve: defensive optional chain; property existence guaranteed by hasOwn check above */

package/dist/index.js

@@ -6885,6 +6885,10 @@ var BuildValidationError = class extends Error {
   }
 };
 
+// ../riviere-schema/dist/schema.js
+var EVENT_NAME_FIELD = "eventName";
+var SUBSCRIBED_EVENTS_FIELD = "subscribedEvents";
+
 // ../riviere-schema/dist/validation.js
 var import_ajv = __toESM(require_ajv(), 1);
 var import_ajv_formats = __toESM(require_dist(), 1);
@@ -25556,7 +25560,6 @@ var COMPONENT_TYPES = [
   "domainOp",
   "event",
   "eventHandler",
-  "eventPublisher",
   "ui"
 ];
 function extractComponents(project, sourceFilePaths, config2, globMatcher, configDir) {
@@ -25715,7 +25718,6 @@ function resolveModule(moduleConfig, loader) {
     domainOp: requireRule(moduleConfig.domainOp, "domainOp", moduleConfig.name),
     event: requireRule(moduleConfig.event, "event", moduleConfig.name),
     eventHandler: requireRule(moduleConfig.eventHandler, "eventHandler", moduleConfig.name),
-    eventPublisher: requireRule(moduleConfig.eventPublisher, "eventPublisher", moduleConfig.name),
     ui: requireRule(moduleConfig.ui, "ui", moduleConfig.name),
     ...moduleConfig.customTypes !== void 0 && { customTypes: moduleConfig.customTypes }
   };
@@ -25735,7 +25737,6 @@ function resolveModuleWithExtends(moduleConfig, extendsSource, loader) {
     domainOp: moduleConfig.domainOp ?? baseModule.domainOp,
     event: moduleConfig.event ?? baseModule.event,
     eventHandler: moduleConfig.eventHandler ?? baseModule.eventHandler,
-    eventPublisher: moduleConfig.eventPublisher ?? baseModule.eventPublisher,
     ui: moduleConfig.ui ?? baseModule.ui,
     ...mergedCustomTypes !== void 0 && { customTypes: mergedCustomTypes }
   };
@@ -28195,90 +28196,104 @@ function traceNonComponent(project, componentIndex, source, typeName, calledMeth
   }
 }
 
-// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/async-detection/detect-publish-connections.js
-function detectPublishConnections(components, options) {
-  const publishers = components.filter((c) => c.type === "eventPublisher");
+// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/async-detection/async-detection-types.js
+function toSourceLocation(component, repository) {
+  return {
+    repository,
+    filePath: component.location.file,
+    lineNumber: component.location.line
+  };
+}
+
+// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/async-detection/detect-event-publisher-connections.js
+function detectEventPublisherConnections(components, eventPublishers, options) {
+  if (eventPublishers.length === 0) {
+    return [];
+  }
   const events = components.filter((c) => c.type === "event");
-  const repository = options.repository;
-  return publishers.flatMap((publisher) => {
-    const publishedEventType = publisher.metadata["publishedEventType"];
-    const sourceLocation = {
-      repository,
-      filePath: publisher.location.file,
-      lineNumber: publisher.location.line
-    };
-    if (typeof publishedEventType !== "string") {
-      return [handleMissingMetadata(publisher, options, sourceLocation)];
-    }
-    return resolvePublishTarget(publisher, publishedEventType, events, options, sourceLocation);
+  return eventPublishers.flatMap((publisherConfig) => {
+    const { fromType, metadataKey } = publisherConfig;
+    const publishers = components.filter((c) => c.type === fromType);
+    return publishers.flatMap((publisher) => {
+      const publishedEventType = publisher.metadata[metadataKey];
+      if (Array.isArray(publishedEventType)) {
+        const validTypes = publishedEventType.filter((t) => typeof t === "string" && t.trim() !== "");
+        if (validTypes.length === 0) {
+          return [handleMissingMetadata(publisher, metadataKey, options)];
+        }
+        return validTypes.flatMap((t) => resolvePublishTarget(publisher, t, events, options));
+      }
+      if (typeof publishedEventType !== "string" || publishedEventType.trim() === "") {
+        return [handleMissingMetadata(publisher, metadataKey, options)];
+      }
+      return resolvePublishTarget(publisher, publishedEventType, events, options);
+    });
   });
 }
-function handleMissingMetadata(publisher, options, sourceLocation) {
+function handleMissingMetadata(publisher, metadataKey, options) {
   if (options.strict) {
     throw new ConnectionDetectionError({
-      file: sourceLocation.filePath,
-      line: sourceLocation.lineNumber,
+      file: publisher.location.file,
+      line: publisher.location.line,
       typeName: publisher.name,
-      reason: 'eventPublisher is missing required "publishedEventType" metadata'
+      reason: `published event type in "${metadataKey}" metadata is missing or invalid`
     });
   }
   return {
     source: componentIdentity(publisher),
     target: "_unresolved",
     type: "async",
-    sourceLocation,
-    _uncertain: `eventPublisher "${publisher.name}" is missing required "publishedEventType" metadata`
+    sourceLocation: toSourceLocation(publisher, options.repository),
+    _uncertain: `event publisher "${publisher.name}" is missing required "${metadataKey}" metadata`
   };
 }
-function resolvePublishTarget(publisher, publishedEventType, events, options, sourceLocation) {
-  const matchingEvents = events.filter((e) => e.metadata["eventName"] === publishedEventType);
+function resolvePublishTarget(publisher, publishedEventType, events, options) {
+  const matchingEvents = events.filter((e) => e.metadata[EVENT_NAME_FIELD] === publishedEventType);
   if (matchingEvents.length === 0) {
-    return [handleNoMatch(publisher, publishedEventType, options, sourceLocation)];
+    return [handleNoMatch(publisher, publishedEventType, options)];
   }
   if (matchingEvents.length > 1) {
-    return [
-      handleAmbiguousMatch(publisher, publishedEventType, matchingEvents.length, options, sourceLocation)
-    ];
+    return [handleAmbiguousMatch(publisher, publishedEventType, matchingEvents.length, options)];
   }
   return matchingEvents.map((event) => ({
     source: componentIdentity(publisher),
     target: componentIdentity(event),
     type: "async",
-    sourceLocation
+    sourceLocation: toSourceLocation(publisher, options.repository)
   }));
 }
-function handleAmbiguousMatch(publisher, publishedEventType, matchCount, options, sourceLocation) {
+function handleAmbiguousMatch(publisher, publishedEventType, matchCount, options) {
   if (options.strict) {
     throw new ConnectionDetectionError({
-      file: sourceLocation.filePath,
-      line: sourceLocation.lineNumber,
+      file: publisher.location.file,
+      line: publisher.location.line,
       typeName: publisher.name,
-      reason: `publishedEventType "${publishedEventType}" matches ${matchCount} Event components (ambiguous)`
+      reason: `published event "${publishedEventType}" matches ${matchCount} Event components (ambiguous)`
     });
   }
   return {
     source: componentIdentity(publisher),
     target: "_unresolved",
     type: "async",
-    sourceLocation,
-    _uncertain: `ambiguous: ${matchCount} events match publishedEventType: ${publishedEventType}`
+    sourceLocation: toSourceLocation(publisher, options.repository),
+    _uncertain: `ambiguous: ${matchCount} events match published event type: ${publishedEventType}`
   };
 }
-function handleNoMatch(publisher, publishedEventType, options, sourceLocation) {
+function handleNoMatch(publisher, publishedEventType, options) {
   if (options.strict) {
     throw new ConnectionDetectionError({
-      file: sourceLocation.filePath,
-      line: sourceLocation.lineNumber,
+      file: publisher.location.file,
+      line: publisher.location.line,
       typeName: publisher.name,
-      reason: `publishedEventType "${publishedEventType}" does not match any Event component`
+      reason: `published event "${publishedEventType}" does not match any Event component`
     });
   }
   return {
     source: componentIdentity(publisher),
     target: "_unresolved",
     type: "async",
-    sourceLocation,
-    _uncertain: `no event found for publishedEventType: ${publishedEventType}`
+    sourceLocation: toSourceLocation(publisher, options.repository),
+    _uncertain: `no event found for published event type: ${publishedEventType}`
   };
 }
 
@@ -28289,15 +28304,8 @@ function detectSubscribeConnections(components, options) {
   const repository = options.repository;
   return eventHandlers.flatMap((handler) => getSubscribedEvents(handler).flatMap((eventName) => resolveSubscription(handler, eventName, events, options, repository)));
 }
-function toSourceLocation(component, repository) {
-  return {
-    repository,
-    filePath: component.location.file,
-    lineNumber: component.location.line
-  };
-}
 function resolveSubscription(handler, eventName, events, options, repository) {
-  const matchingEvents = events.filter((e) => e.metadata["eventName"] === eventName);
+  const matchingEvents = events.filter((e) => e.metadata[EVENT_NAME_FIELD] === eventName);
   if (matchingEvents.length === 0) {
     return [handleNoMatch2(handler, eventName, options, repository)];
   }
@@ -28346,7 +28354,7 @@ function handleNoMatch2(handler, eventName, options, repository) {
   };
 }
 function getSubscribedEvents(handler) {
-  const raw = handler.metadata["subscribedEvents"];
+  const raw = handler.metadata[SUBSCRIBED_EVENTS_FIELD];
   if (!Array.isArray(raw)) {
     return [];
   }
@@ -28615,15 +28623,13 @@ function detectPerModuleConnections(project, components, options, globMatcher) {
 function detectCrossModuleConnections(allComponents, options) {
   const strict = options.allowIncomplete !== true;
   const repository = options.repository;
-  const asyncStart = performance.now();
-  const publishLinks = detectPublishConnections(allComponents, {
-    strict,
-    repository
-  });
-  const subscribeLinks = detectSubscribeConnections(allComponents, {
+  const asyncOptions = {
     strict,
     repository
-  });
+  };
+  const asyncStart = performance.now();
+  const publishLinks = detectEventPublisherConnections(allComponents, options.eventPublishers ?? [], asyncOptions);
+  const subscribeLinks = detectSubscribeConnections(allComponents, asyncOptions);
   const asyncDetectionMs = performance.now() - asyncStart;
   return {
     links: [...publishLinks, ...subscribeLinks],
@@ -28662,7 +28668,6 @@ function getBuiltInRule(module, componentType) {
     domainOp: module.domainOp,
     event: module.event,
     eventHandler: module.eventHandler,
-    eventPublisher: module.eventPublisher,
     ui: module.ui
   };
   const rule = ruleMap[componentType];
@@ -28678,7 +28683,6 @@ function findDetectionRule(module, componentType) {
     "domainOp",
     "event",
     "eventHandler",
-    "eventPublisher",
     "ui"
   ];
   if (builtInTypes.includes(componentType)) {
@@ -28729,10 +28733,7 @@ function evaluateClassRule(rule, classDecl) {
   if ("fromClassName" in rule) {
     return evaluateFromClassNameRule(rule, classDecl);
   }
-  if (!("fromProperty" in rule)) {
-    throw new ExtractionError("Unsupported extraction rule type for class-based component", classDecl.getSourceFile().getFilePath(), classDecl.getStartLineNumber());
-  }
-  return evaluateFromPropertyRule(rule, classDecl);
+  throw new ExtractionError("Unsupported extraction rule type for class-based component", classDecl.getSourceFile().getFilePath(), classDecl.getStartLineNumber());
 }
 function evaluateRule2(rule, draft, project) {
   if ("literal" in rule) {
@@ -28749,6 +28750,10 @@ function evaluateRule2(rule, draft, project) {
     const classDecl2 = findContainingClass(project, draft);
     return evaluateFromGenericArgRule(rule, classDecl2);
   }
+  if ("fromProperty" in rule) {
+    const classDecl2 = findContainingClass(project, draft);
+    return evaluateFromPropertyRule(rule, classDecl2);
+  }
   if ("fromParameterType" in rule) {
     const methodDecl = findMethodAtLine(project, draft);
     const params = methodDecl.getParameters();
@@ -28929,10 +28934,6 @@ var extraction_config_schema_default = {
           $ref: "#/$defs/componentRule",
           description: "Detection rule for EventHandler components"
         },
-        eventPublisher: {
-          $ref: "#/$defs/componentRule",
-          description: "Detection rule for EventPublisher components"
-        },
         ui: {
           $ref: "#/$defs/componentRule",
           description: "Detection rule for UI components"
@@ -28945,7 +28946,7 @@ var extraction_config_schema_default = {
           }
         },
         connections: {
-          $ref: "#/$defs/connectionsConfig",
+          $ref: "#/$defs/moduleConnectionsConfig",
           description: "Module-level connection detection patterns additive to global"
         }
       },
@@ -28955,7 +28956,7 @@ var extraction_config_schema_default = {
         }
       },
       then: {
-        required: ["api", "useCase", "domainOp", "event", "eventHandler", "eventPublisher", "ui"]
+        required: ["api", "useCase", "domainOp", "event", "eventHandler", "ui"]
       }
     },
     componentRule: {
@@ -29449,7 +29450,6 @@ var extraction_config_schema_default = {
     connectionsConfig: {
       type: "object",
       description: "Connection detection configuration with pattern definitions",
-      required: ["patterns"],
       additionalProperties: false,
       properties: {
         patterns: {
@@ -29459,6 +29459,47 @@ var extraction_config_schema_default = {
           items: {
             $ref: "#/$defs/connectionPattern"
           }
+        },
+        eventPublishers: {
+          type: "array",
+          description: "Declares which custom component types publish events and how to detect the connections",
+          minItems: 1,
+          items: {
+            $ref: "#/$defs/eventPublisherConfig"
+          }
+        }
+      }
+    },
+    moduleConnectionsConfig: {
+      type: "object",
+      description: "Module-level connection detection configuration (patterns only \u2014 eventPublishers is top-level only)",
+      additionalProperties: false,
+      properties: {
+        patterns: {
+          type: "array",
+          description: "Connection detection patterns",
+          minItems: 1,
+          items: {
+            $ref: "#/$defs/connectionPattern"
+          }
+        }
+      }
+    },
+    eventPublisherConfig: {
+      type: "object",
+      description: "Declares a custom component type as an event publisher",
+      required: ["fromType", "metadataKey"],
+      additionalProperties: false,
+      properties: {
+        fromType: {
+          type: "string",
+          description: "The custom component type name \u2014 must be defined in customTypes in at least one module",
+          minLength: 1
+        },
+        metadataKey: {
+          type: "string",
+          description: "The metadata key on this component type that holds the published event type name",
+          minLength: 1
         }
       }
     },
@@ -29594,7 +29635,6 @@ var REQUIRED_FIELDS = {
   api: ["apiType"],
   event: ["eventName"],
   eventHandler: ["subscribedEvents"],
-  eventPublisher: [],
   domainOp: ["operationName"],
   ui: ["route"],
   useCase: []
@@ -29605,7 +29645,6 @@ var COMPONENT_TYPES2 = [
   "domainOp",
   "event",
   "eventHandler",
-  "eventPublisher",
   "ui"
 ];
 var ajv2 = new import_ajv2.default({ allErrors: true });
@@ -29684,6 +29723,54 @@ function validateAllExtractionRules(config2) {
     return validateModuleExtractionRules(module, index);
   });
 }
+function collectCustomTypeExtractedFields(config2) {
+  const fieldsByType = /* @__PURE__ */ new Map();
+  for (const module of config2.modules) {
+    if ("$ref" in module || module.customTypes === void 0) {
+      continue;
+    }
+    for (const [typeName, rule] of Object.entries(module.customTypes)) {
+      const existing = fieldsByType.get(typeName) ?? /* @__PURE__ */ new Set();
+      for (const key of Object.keys(rule.extract ?? {})) {
+        existing.add(key);
+      }
+      fieldsByType.set(typeName, existing);
+    }
+  }
+  return fieldsByType;
+}
+function validateEventPublishers(connections, customTypeFields) {
+  if (connections.eventPublishers === void 0) {
+    return [];
+  }
+  return connections.eventPublishers.flatMap((publisher, index) => {
+    const extractedFields = customTypeFields.get(publisher.fromType);
+    if (extractedFields === void 0) {
+      return [
+        {
+          path: `/connections/eventPublishers/${index}/fromType`,
+          message: `"${publisher.fromType}" is not defined as a customType in any module. Add a customType named "${publisher.fromType}" to at least one module.`
+        }
+      ];
+    }
+    if (!extractedFields.has(publisher.metadataKey)) {
+      return [
+        {
+          path: `/connections/eventPublishers/${index}/fromType`,
+          message: `customType "${publisher.fromType}" does not extract "${publisher.metadataKey}". Add extract["${publisher.metadataKey}"] to that custom type.`
+        }
+      ];
+    }
+    return [];
+  });
+}
+function validateConnectionsConfig(config2) {
+  if (config2.connections === void 0) {
+    return [];
+  }
+  const customTypeFields = collectCustomTypeExtractedFields(config2);
+  return validateEventPublishers(config2.connections, customTypeFields);
+}
 function validateExtractionConfigSchema(data) {
   const schemaValid = validate2(data) === true;
   if (!schemaValid) {
@@ -29701,7 +29788,7 @@ function validateExtractionConfig(data) {
   if (!isValidExtractionConfig(data)) {
     return validateExtractionConfigSchema(data);
   }
-  const semanticErrors = validateAllExtractionRules(data);
+  const semanticErrors = [...validateAllExtractionRules(data), ...validateConnectionsConfig(data)];
   if (semanticErrors.length > 0) {
     return {
       valid: false,
@@ -29717,10 +29804,10 @@ function formatValidationErrors2(errors) {
   return formatValidationErrorsInternal2(errors);
 }
 function parseExtractionConfig(data) {
-  if (isValidExtractionConfig(data)) {
+  const result = validateExtractionConfig(data);
+  if (result.valid && isValidExtractionConfig(data)) {
     return data;
   }
-  const result = validateExtractionConfig(data);
   throw new ExtractionConfigValidationError(result.errors);
 }
 
@@ -30073,7 +30160,8 @@ var ExtractionProject = class {
     }
     const crossResult = detectCrossModuleConnections(enrichedComponents, {
       allowIncomplete,
-      repository: this.repositoryName
+      repository: this.repositoryName,
+      eventPublishers: this.resolvedConfig.connections?.eventPublishers
     });
     links.push(...crossResult.links);
     timings.push({
@@ -30379,7 +30467,6 @@ ${formatValidationErrors2(validationResult.errors)}`
       domainOp: parsed.domainOp ?? NOT_USED,
       event: parsed.event ?? NOT_USED,
       eventHandler: parsed.eventHandler ?? NOT_USED,
-      eventPublisher: parsed.eventPublisher ?? NOT_USED,
       ui: parsed.ui ?? NOT_USED
     };
   }
@@ -31202,7 +31289,6 @@ export {
 /* istanbul ignore else -- @preserve: false branch is unreachable; FindTarget is exhaustive */
 /* istanbul ignore next -- @preserve: unreachable with valid FindTarget type; defensive fallback */
 /* v8 ignore next -- @preserve: getExtends() !== undefined guarantees getBaseClass() returns a value */
-/* istanbul ignore next -- @preserve: only fromProperty reaches here; defensive guard */
 /* istanbul ignore next -- @preserve: catch always receives Error instances from ExtractionError */
 /* v8 ignore start -- @preserve: default executor delegates to execFileSync; tested via CLI integration */
 /* v8 ignore next -- @preserve: defensive optional chain; property existence guaranteed by hasOwn check above */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@living-architecture/riviere-cli",
-  "version": "0.9.3",
+  "version": "0.9.5",
   "publishConfig": {
     "access": "public"
   },
@@ -32,10 +32,10 @@
     "glob": "^11.0.2",
     "ts-morph": "^24.0.0",
     "yaml": "^2.7.0",
-    "@living-architecture/riviere-builder": "0.7.3",
-    "@living-architecture/riviere-extract-ts": "0.4.2",
-    "@living-architecture/riviere-extract-config": "0.5.3",
-    "@living-architecture/riviere-schema": "0.6.3",
-    "@living-architecture/riviere-query": "0.6.3"
+    "@living-architecture/riviere-builder": "0.7.4",
+    "@living-architecture/riviere-extract-ts": "0.4.4",
+    "@living-architecture/riviere-query": "0.6.4",
+    "@living-architecture/riviere-schema": "0.6.4",
+    "@living-architecture/riviere-extract-config": "0.5.4"
   }
 }