@living-architecture/riviere-extract-config-published-language 0.7.0

package/dist/index.js

@@ -0,0 +1,1102 @@
+// src/published-language/validated-configuration.ts
+var REQUIRED_FIELDS = {
+  api: ["apiType"],
+  useCase: [],
+  domainOp: ["operationName"],
+  event: ["eventName"],
+  eventHandler: ["subscribedEvents"],
+  ui: ["route"]
+};
+var COMPONENT_TYPES = [
+  "api",
+  "useCase",
+  "domainOp",
+  "event",
+  "eventHandler",
+  "ui"
+];
+var ValidatedModule = class _ValidatedModule {
+  #values;
+  constructor(values) {
+    this.#values = values;
+  }
+  static parse(input) {
+    const errors = validateModule(input);
+    if (errors.length > 0) {
+      return { success: false, errors };
+    }
+    return { success: true, data: new _ValidatedModule(input) };
+  }
+  get name() {
+    return this.#values.name;
+  }
+  get domain() {
+    return this.#values.domain;
+  }
+  get path() {
+    return this.#values.path;
+  }
+  get glob() {
+    return this.#values.glob;
+  }
+  get modules() {
+    return this.#values.modules;
+  }
+  get api() {
+    return this.#values.api;
+  }
+  get useCase() {
+    return this.#values.useCase;
+  }
+  get domainOp() {
+    return this.#values.domainOp;
+  }
+  get event() {
+    return this.#values.event;
+  }
+  get eventHandler() {
+    return this.#values.eventHandler;
+  }
+  get ui() {
+    return this.#values.ui;
+  }
+  get customTypes() {
+    return this.#values.customTypes;
+  }
+  ruleFor(componentType) {
+    return this.#values[componentType];
+  }
+};
+var ValidatedConfiguration = class _ValidatedConfiguration {
+  constructor(modules, connections, schema) {
+    this.connections = connections;
+    this.schema = schema;
+    this.#modules = modules;
+  }
+  #modules;
+  static parse(input) {
+    const modules = [];
+    const moduleErrors = [];
+    input.modules.forEach((module, index) => {
+      const result = ValidatedModule.parse(module);
+      if (result.success) {
+        modules.push(result.data);
+        return;
+      }
+      moduleErrors.push(
+        ...result.errors.map((error) => ({
+          ...error,
+          path: `/modules/${index}${error.path}`
+        }))
+      );
+    });
+    const connectionErrors = validateConnections(input);
+    const errors = [...moduleErrors, ...connectionErrors];
+    if (errors.length > 0) {
+      return { success: false, errors };
+    }
+    return {
+      success: true,
+      data: new _ValidatedConfiguration(modules, input.connections, input.$schema)
+    };
+  }
+  get modules() {
+    return this.#modules;
+  }
+};
+function validateModule(module) {
+  return COMPONENT_TYPES.flatMap((componentType) => {
+    const rule = module[componentType];
+    if ("notUsed" in rule) {
+      return [];
+    }
+    const extractedFields = new Set(Object.keys(rule.extract ?? {}));
+    const missingFields = REQUIRED_FIELDS[componentType].filter(
+      (field) => !extractedFields.has(field)
+    );
+    return missingFields.length === 0 ? [] : [
+      {
+        path: `/${componentType}`,
+        message: `Missing required extraction rules: ${missingFields.join(", ")}. Add extraction rules to the 'extract' block or use 'notUsed: true' if not extracting ${componentType} components.`
+      }
+    ];
+  });
+}
+function validateConnections(input) {
+  if (input.connections === void 0) return [];
+  const customTypeFields = /* @__PURE__ */ new Map();
+  for (const module of input.modules) {
+    for (const [typeName, rule] of Object.entries(module.customTypes ?? {})) {
+      const fields = customTypeFields.get(typeName) ?? /* @__PURE__ */ new Set();
+      for (const field of Object.keys(rule.extract ?? {})) fields.add(field);
+      customTypeFields.set(typeName, fields);
+    }
+  }
+  return [
+    ...validateEventPublishers(input.connections, customTypeFields),
+    ...validateHttpLinks(input.connections, customTypeFields)
+  ];
+}
+function validateEventPublishers(connections, customTypeFields) {
+  return (connections.eventPublishers ?? []).flatMap((publisher, index) => {
+    const fields = customTypeFields.get(publisher.fromType);
+    if (fields === void 0) {
+      return [
+        {
+          path: `/connections/eventPublishers/${index}/fromType`,
+          message: `"${publisher.fromType}" is not defined as a customType in any module.`
+        }
+      ];
+    }
+    return fields.has(publisher.metadataKey) ? [] : [
+      {
+        path: `/connections/eventPublishers/${index}/metadataKey`,
+        message: `customType "${publisher.fromType}" does not extract "${publisher.metadataKey}".`
+      }
+    ];
+  });
+}
+function validateHttpLinks(connections, customTypeFields) {
+  return (connections.httpLinks ?? []).flatMap((httpLink, index) => {
+    const fields = customTypeFields.get(httpLink.fromCustomType);
+    if (fields === void 0) {
+      return [
+        {
+          path: `/connections/httpLinks/${index}/fromCustomType`,
+          message: `"${httpLink.fromCustomType}" is not defined as a customType in any module.`
+        }
+      ];
+    }
+    const requiredFields = [httpLink.matchDomainBy, ...httpLink.matchApiBy];
+    return requiredFields.flatMap(
+      (field) => fields.has(field) ? [] : [
+        {
+          path: `/connections/httpLinks/${index}`,
+          message: `customType "${httpLink.fromCustomType}" does not extract "${field}".`
+        }
+      ]
+    );
+  });
+}
+
+// src/published-language/validation.ts
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+
+// extraction-config.schema.json
+var extraction_config_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://living-architecture.dev/schemas/extraction-config.schema.json",
+  title: "Extraction Config",
+  description: "Configuration for extracting architectural components from source code",
+  type: "object",
+  required: ["modules"],
+  additionalProperties: false,
+  properties: {
+    $schema: {
+      type: "string",
+      description: "JSON Schema reference"
+    },
+    modules: {
+      type: "array",
+      description: "Module definitions for component extraction",
+      minItems: 1,
+      items: {
+        oneOf: [{ $ref: "#/$defs/module" }, { $ref: "#/$defs/moduleRef" }]
+      }
+    },
+    connections: {
+      $ref: "#/$defs/connectionsConfig",
+      description: "Connection detection configuration"
+    }
+  },
+  $defs: {
+    moduleRef: {
+      type: "object",
+      description: "Reference to an external module definition file",
+      required: ["$ref"],
+      additionalProperties: false,
+      properties: {
+        $ref: {
+          type: "string",
+          description: "File path to a module definition (relative to this config file)",
+          minLength: 1
+        }
+      }
+    },
+    module: {
+      type: "object",
+      description: "A module defines extraction rules for a path pattern",
+      required: ["name", "domain", "path", "glob"],
+      additionalProperties: false,
+      properties: {
+        name: {
+          type: "string",
+          description: "Extraction config module identifier",
+          minLength: 1
+        },
+        domain: {
+          type: "string",
+          description: "Riviere graph domain this module belongs to",
+          minLength: 1
+        },
+        path: {
+          type: "string",
+          description: "Module root directory relative to config file",
+          minLength: 1
+        },
+        modules: {
+          type: "string",
+          description: "Path pattern with {module} placeholder for resolving module names from file paths",
+          pattern: "\\{module\\}"
+        },
+        glob: {
+          type: "string",
+          description: "Glob pattern for source files within the module directory",
+          minLength: 1
+        },
+        extends: {
+          type: "string",
+          description: "Package name or file path to inherit component rules from",
+          minLength: 1
+        },
+        api: {
+          $ref: "#/$defs/componentRule",
+          description: "Detection rule for API components"
+        },
+        useCase: {
+          $ref: "#/$defs/componentRule",
+          description: "Detection rule for UseCase components"
+        },
+        domainOp: {
+          $ref: "#/$defs/componentRule",
+          description: "Detection rule for DomainOp components"
+        },
+        event: {
+          $ref: "#/$defs/componentRule",
+          description: "Detection rule for Event components"
+        },
+        eventHandler: {
+          $ref: "#/$defs/componentRule",
+          description: "Detection rule for EventHandler components"
+        },
+        ui: {
+          $ref: "#/$defs/componentRule",
+          description: "Detection rule for UI components"
+        },
+        customTypes: {
+          type: "object",
+          description: "User-defined component types with their detection rules",
+          additionalProperties: {
+            $ref: "#/$defs/detectionRule"
+          }
+        }
+      },
+      if: {
+        not: {
+          required: ["extends"]
+        }
+      },
+      then: {
+        required: ["api", "useCase", "domainOp", "event", "eventHandler", "ui"]
+      }
+    },
+    componentRule: {
+      oneOf: [
+        {
+          $ref: "#/$defs/notUsed"
+        },
+        {
+          $ref: "#/$defs/detectionRule"
+        }
+      ]
+    },
+    notUsed: {
+      type: "object",
+      description: "Marks this component type as not used in the module",
+      required: ["notUsed"],
+      additionalProperties: false,
+      properties: {
+        notUsed: {
+          type: "boolean",
+          const: true
+        }
+      }
+    },
+    detectionRule: {
+      type: "object",
+      description: "Rule for detecting components of this type",
+      required: ["find", "where"],
+      additionalProperties: false,
+      properties: {
+        find: {
+          $ref: "#/$defs/findTarget"
+        },
+        where: {
+          $ref: "#/$defs/predicate"
+        },
+        extract: {
+          $ref: "#/$defs/extractBlock",
+          description: "Extraction rules for metadata fields"
+        }
+      }
+    },
+    extractBlock: {
+      type: "object",
+      description: "Extraction rules mapping field names to extraction rules",
+      additionalProperties: {
+        $ref: "#/$defs/extractionRule"
+      }
+    },
+    extractionRule: {
+      oneOf: [
+        { $ref: "#/$defs/literalExtractionRule" },
+        { $ref: "#/$defs/fromClassNameExtractionRule" },
+        { $ref: "#/$defs/fromMethodNameExtractionRule" },
+        { $ref: "#/$defs/fromFilePathExtractionRule" },
+        { $ref: "#/$defs/fromPropertyExtractionRule" },
+        { $ref: "#/$defs/fromDecoratorArgExtractionRule" },
+        { $ref: "#/$defs/fromClassDecoratorArgExtractionRule" },
+        { $ref: "#/$defs/fromDecoratorNameExtractionRule" },
+        { $ref: "#/$defs/fromGenericArgExtractionRule" },
+        { $ref: "#/$defs/fromMethodSignatureExtractionRule" },
+        { $ref: "#/$defs/fromConstructorParamsExtractionRule" },
+        { $ref: "#/$defs/fromParameterTypeExtractionRule" }
+      ]
+    },
+    fromMethodNameExtractionRule: {
+      type: "object",
+      description: "Extracts value from the method name",
+      required: ["fromMethodName"],
+      additionalProperties: false,
+      properties: {
+        fromMethodName: {
+          oneOf: [
+            { type: "boolean", const: true },
+            {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                transform: { $ref: "#/$defs/transform" }
+              }
+            }
+          ]
+        }
+      }
+    },
+    fromFilePathExtractionRule: {
+      type: "object",
+      description: "Extracts value from the file path using regex capture",
+      required: ["fromFilePath"],
+      additionalProperties: false,
+      properties: {
+        fromFilePath: {
+          type: "object",
+          required: ["pattern", "capture"],
+          additionalProperties: false,
+          properties: {
+            pattern: { type: "string", minLength: 1 },
+            capture: { type: "integer", minimum: 0 },
+            transform: { $ref: "#/$defs/transform" }
+          }
+        }
+      }
+    },
+    fromPropertyExtractionRule: {
+      type: "object",
+      description: "Extracts value from a class property",
+      required: ["fromProperty"],
+      additionalProperties: false,
+      properties: {
+        fromProperty: {
+          type: "object",
+          required: ["name", "kind"],
+          additionalProperties: false,
+          properties: {
+            name: { type: "string", minLength: 1 },
+            kind: { type: "string", enum: ["static", "instance"] },
+            transform: { $ref: "#/$defs/transform" }
+          }
+        }
+      }
+    },
+    fromDecoratorArgExtractionRule: {
+      type: "object",
+      description: "Extracts value from decorator argument",
+      required: ["fromDecoratorArg"],
+      additionalProperties: false,
+      properties: {
+        fromDecoratorArg: {
+          type: "object",
+          additionalProperties: false,
+          minProperties: 1,
+          properties: {
+            decorator: { type: "string", minLength: 1 },
+            position: { type: "integer", minimum: 0 },
+            name: { type: "string", minLength: 1 },
+            transform: { $ref: "#/$defs/transform" }
+          }
+        }
+      }
+    },
+    fromClassDecoratorArgExtractionRule: {
+      type: "object",
+      description: "Extracts value from decorator argument on the containing class",
+      required: ["fromClassDecoratorArg"],
+      additionalProperties: false,
+      properties: {
+        fromClassDecoratorArg: {
+          type: "object",
+          required: ["decorator"],
+          additionalProperties: false,
+          properties: {
+            decorator: { type: "string", minLength: 1 },
+            position: { type: "integer", minimum: 0 },
+            name: { type: "string", minLength: 1 },
+            transform: { $ref: "#/$defs/transform" }
+          },
+          oneOf: [
+            {
+              required: ["position"],
+              not: { required: ["name"] }
+            },
+            {
+              required: ["name"],
+              not: { required: ["position"] }
+            }
+          ]
+        }
+      }
+    },
+    fromDecoratorNameExtractionRule: {
+      type: "object",
+      description: "Extracts value from the decorator name itself",
+      required: ["fromDecoratorName"],
+      additionalProperties: false,
+      properties: {
+        fromDecoratorName: {
+          oneOf: [
+            { type: "boolean", const: true },
+            {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                mapping: {
+                  type: "object",
+                  additionalProperties: { type: "string" },
+                  minProperties: 1
+                },
+                transform: { $ref: "#/$defs/transform" }
+              }
+            }
+          ]
+        }
+      }
+    },
+    fromGenericArgExtractionRule: {
+      type: "object",
+      description: "Extracts value from generic type argument",
+      required: ["fromGenericArg"],
+      additionalProperties: false,
+      properties: {
+        fromGenericArg: {
+          type: "object",
+          required: ["interface", "position"],
+          additionalProperties: false,
+          properties: {
+            interface: { type: "string", minLength: 1 },
+            position: { type: "integer", minimum: 0 },
+            transform: { $ref: "#/$defs/transform" }
+          }
+        }
+      }
+    },
+    fromMethodSignatureExtractionRule: {
+      type: "object",
+      description: "Extracts method parameters and return type",
+      required: ["fromMethodSignature"],
+      additionalProperties: false,
+      properties: {
+        fromMethodSignature: {
+          type: "boolean",
+          const: true
+        }
+      }
+    },
+    fromConstructorParamsExtractionRule: {
+      type: "object",
+      description: "Extracts constructor parameter names and types",
+      required: ["fromConstructorParams"],
+      additionalProperties: false,
+      properties: {
+        fromConstructorParams: {
+          type: "boolean",
+          const: true
+        }
+      }
+    },
+    fromParameterTypeExtractionRule: {
+      type: "object",
+      description: "Extracts type name of parameter at position",
+      required: ["fromParameterType"],
+      additionalProperties: false,
+      properties: {
+        fromParameterType: {
+          type: "object",
+          required: ["position"],
+          additionalProperties: false,
+          properties: {
+            position: { type: "integer", minimum: 0 },
+            transform: { $ref: "#/$defs/transform" }
+          }
+        }
+      }
+    },
+    fromClassNameExtractionRule: {
+      type: "object",
+      description: "Extracts value from the class name",
+      required: ["fromClassName"],
+      additionalProperties: false,
+      properties: {
+        fromClassName: {
+          oneOf: [
+            { type: "boolean", const: true },
+            {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                transform: { $ref: "#/$defs/transform" }
+              }
+            }
+          ],
+          description: "Extract from class name, optionally with transform"
+        }
+      }
+    },
+    transform: {
+      type: "object",
+      description: "Transform operations to apply to extracted value",
+      additionalProperties: false,
+      minProperties: 1,
+      properties: {
+        stripSuffix: { type: "string", minLength: 1 },
+        stripPrefix: { type: "string", minLength: 1 },
+        toLowerCase: { type: "boolean", const: true },
+        toUpperCase: { type: "boolean", const: true },
+        kebabToPascal: { type: "boolean", const: true },
+        pascalToKebab: { type: "boolean", const: true }
+      }
+    },
+    literalExtractionRule: {
+      type: "object",
+      description: "Extracts a hardcoded literal value",
+      required: ["literal"],
+      additionalProperties: false,
+      properties: {
+        literal: {
+          oneOf: [
+            { type: "string", minLength: 1 },
+            { type: "boolean" },
+            { type: "number" }
+          ],
+          description: "Literal value to use for this field"
+        }
+      }
+    },
+    findTarget: {
+      type: "string",
+      description: "The code construct to search for",
+      enum: ["classes", "methods", "functions"]
+    },
+    predicate: {
+      oneOf: [
+        {
+          $ref: "#/$defs/hasDecoratorPredicate"
+        },
+        {
+          $ref: "#/$defs/hasJSDocPredicate"
+        },
+        {
+          $ref: "#/$defs/extendsClassPredicate"
+        },
+        {
+          $ref: "#/$defs/implementsInterfacePredicate"
+        },
+        {
+          $ref: "#/$defs/nameEndsWithPredicate"
+        },
+        {
+          $ref: "#/$defs/nameMatchesPredicate"
+        },
+        {
+          $ref: "#/$defs/inClassWithPredicate"
+        },
+        {
+          $ref: "#/$defs/andPredicate"
+        },
+        {
+          $ref: "#/$defs/orPredicate"
+        }
+      ]
+    },
+    hasDecoratorPredicate: {
+      type: "object",
+      description: "Matches if the target has a specified decorator",
+      required: ["hasDecorator"],
+      additionalProperties: false,
+      properties: {
+        hasDecorator: {
+          type: "object",
+          required: ["name"],
+          additionalProperties: false,
+          properties: {
+            name: {
+              oneOf: [
+                {
+                  type: "string",
+                  minLength: 1
+                },
+                {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    minLength: 1
+                  },
+                  minItems: 1
+                }
+              ],
+              description: "Decorator name(s) to match"
+            },
+            from: {
+              type: "string",
+              minLength: 1,
+              description: "Package the decorator is imported from"
+            }
+          }
+        }
+      }
+    },
+    hasJSDocPredicate: {
+      type: "object",
+      description: "Matches if the target has a specified JSDoc tag",
+      required: ["hasJSDoc"],
+      additionalProperties: false,
+      properties: {
+        hasJSDoc: {
+          type: "object",
+          required: ["tag"],
+          additionalProperties: false,
+          properties: {
+            tag: {
+              type: "string",
+              minLength: 1,
+              description: "JSDoc tag to match (without @)"
+            }
+          }
+        }
+      }
+    },
+    extendsClassPredicate: {
+      type: "object",
+      description: "Matches if the class extends a specified base class",
+      required: ["extendsClass"],
+      additionalProperties: false,
+      properties: {
+        extendsClass: {
+          type: "object",
+          required: ["name"],
+          additionalProperties: false,
+          properties: {
+            name: {
+              type: "string",
+              minLength: 1,
+              description: "Base class name to match"
+            }
+          }
+        }
+      }
+    },
+    implementsInterfacePredicate: {
+      type: "object",
+      description: "Matches if the class implements a specified interface",
+      required: ["implementsInterface"],
+      additionalProperties: false,
+      properties: {
+        implementsInterface: {
+          type: "object",
+          required: ["name"],
+          additionalProperties: false,
+          properties: {
+            name: {
+              type: "string",
+              minLength: 1,
+              description: "Interface name to match"
+            }
+          }
+        }
+      }
+    },
+    nameEndsWithPredicate: {
+      type: "object",
+      description: "Matches if the target name ends with a specified suffix",
+      required: ["nameEndsWith"],
+      additionalProperties: false,
+      properties: {
+        nameEndsWith: {
+          type: "object",
+          required: ["suffix"],
+          additionalProperties: false,
+          properties: {
+            suffix: {
+              type: "string",
+              minLength: 1,
+              description: "Suffix to match"
+            }
+          }
+        }
+      }
+    },
+    nameMatchesPredicate: {
+      type: "object",
+      description: "Matches if the target name matches a regex pattern",
+      required: ["nameMatches"],
+      additionalProperties: false,
+      properties: {
+        nameMatches: {
+          type: "object",
+          required: ["pattern"],
+          additionalProperties: false,
+          properties: {
+            pattern: {
+              type: "string",
+              minLength: 1,
+              description: "Regex pattern to match against the name"
+            }
+          }
+        }
+      }
+    },
+    inClassWithPredicate: {
+      type: "object",
+      description: "Matches if the method is in a class matching the predicate",
+      required: ["inClassWith"],
+      additionalProperties: false,
+      properties: {
+        inClassWith: {
+          $ref: "#/$defs/predicate",
+          description: "Predicate the containing class must satisfy"
+        }
+      }
+    },
+    andPredicate: {
+      type: "object",
+      description: "Matches if all predicates match",
+      required: ["and"],
+      additionalProperties: false,
+      properties: {
+        and: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/predicate"
+          },
+          minItems: 2,
+          description: "All predicates must match"
+        }
+      }
+    },
+    orPredicate: {
+      type: "object",
+      description: "Matches if any predicate matches",
+      required: ["or"],
+      additionalProperties: false,
+      properties: {
+        or: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/predicate"
+          },
+          minItems: 2,
+          description: "Any predicate must match"
+        }
+      }
+    },
+    connectionsConfig: {
+      type: "object",
+      description: "Connection detection configuration",
+      additionalProperties: false,
+      properties: {
+        eventPublishers: {
+          type: "array",
+          description: "Declares which custom component types publish events and how to detect the connections",
+          minItems: 1,
+          items: {
+            $ref: "#/$defs/eventPublisherConfig"
+          }
+        },
+        httpLinks: {
+          type: "array",
+          description: "Declares how to resolve HTTP client calls into cross-domain Links",
+          minItems: 1,
+          items: {
+            $ref: "#/$defs/httpLinkConfig"
+          }
+        }
+      }
+    },
+    httpLinkConfig: {
+      type: "object",
+      description: "Declares how to resolve HTTP client calls into cross-domain Links",
+      required: ["fromCustomType", "matchDomainBy", "matchApiBy"],
+      additionalProperties: false,
+      properties: {
+        fromCustomType: {
+          type: "string",
+          description: "Custom component type name for HTTP clients \u2014 must be defined in customTypes in at least one module",
+          minLength: 1
+        },
+        matchDomainBy: {
+          type: "string",
+          description: "Metadata key whose value identifies the target domain",
+          minLength: 1
+        },
+        matchApiBy: {
+          type: "array",
+          description: "Metadata keys used to match the target API component",
+          items: {
+            type: "string",
+            minLength: 1
+          },
+          minItems: 1
+        }
+      }
+    },
+    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
+        }
+      }
+    }
+  }
+};
+
+// src/published-language/validation.ts
+var REQUIRED_FIELDS2 = {
+  api: ["apiType"],
+  event: ["eventName"],
+  eventHandler: ["subscribedEvents"],
+  domainOp: ["operationName"],
+  ui: ["route"],
+  useCase: []
+};
+var COMPONENT_TYPES2 = [
+  "api",
+  "useCase",
+  "domainOp",
+  "event",
+  "eventHandler",
+  "ui"
+];
+var ajv = new Ajv({ allErrors: true });
+addFormats(ajv);
+var validate = ajv.compile(extraction_config_schema_default);
+function isValidExtractionConfig(data) {
+  return validate(data) === true;
+}
+function mapAjvErrors(errors) {
+  if (!errors) {
+    return [];
+  }
+  return errors.map((e) => ({
+    path: e.instancePath || "/",
+    message: e.message ?? "unknown error"
+  }));
+}
+function isNotUsed(rule) {
+  return rule !== void 0 && "notUsed" in rule && rule.notUsed === true;
+}
+function hasDetectionRule(rule) {
+  return rule !== void 0 && "find" in rule && "where" in rule;
+}
+function getExtractedFields(rule) {
+  if (!rule || !("extract" in rule) || !rule.extract) {
+    return [];
+  }
+  return Object.keys(rule.extract);
+}
+function validateModuleExtractionRules(module, moduleIndex) {
+  const errors = [];
+  for (const componentType of COMPONENT_TYPES2) {
+    const rule = module[componentType];
+    if (isNotUsed(rule)) {
+      continue;
+    }
+    if (!hasDetectionRule(rule)) {
+      continue;
+    }
+    const requiredFields = REQUIRED_FIELDS2[componentType];
+    if (requiredFields.length === 0) {
+      continue;
+    }
+    const extractedFields = getExtractedFields(rule);
+    const missingFields = requiredFields.filter((field) => !extractedFields.includes(field));
+    if (missingFields.length > 0) {
+      errors.push({
+        path: `/modules/${moduleIndex}/${componentType}`,
+        message: `Missing required extraction rules: ${missingFields.join(", ")}. Add extraction rules to the 'extract' block or use 'notUsed: true' if not extracting ${componentType} components.`
+      });
+    }
+  }
+  return errors;
+}
+function validateAllExtractionRules(config) {
+  return config.modules.flatMap((module, index) => {
+    if ("$ref" in module) {
+      return [];
+    }
+    return validateModuleExtractionRules(module, index);
+  });
+}
+function collectCustomTypeExtractedFields(config) {
+  const fieldsByType = /* @__PURE__ */ new Map();
+  for (const module of config.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 validateEventPublishers2(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 validateHttpLinks2(connections, customTypeFields) {
+  if (connections.httpLinks === void 0) {
+    return [];
+  }
+  return connections.httpLinks.flatMap((httpLink, index) => {
+    const extractedFields = customTypeFields.get(httpLink.fromCustomType);
+    if (extractedFields === void 0) {
+      return [
+        {
+          path: `/connections/httpLinks/${index}/fromCustomType`,
+          message: `"${httpLink.fromCustomType}" is not defined as a customType in any module. Add a customType named "${httpLink.fromCustomType}" to at least one module.`
+        }
+      ];
+    }
+    const errors = [];
+    if (!extractedFields.has(httpLink.matchDomainBy)) {
+      errors.push({
+        path: `/connections/httpLinks/${index}/matchDomainBy`,
+        message: `customType "${httpLink.fromCustomType}" does not extract "${httpLink.matchDomainBy}". Add extract["${httpLink.matchDomainBy}"] to that custom type.`
+      });
+    }
+    for (const field of httpLink.matchApiBy) {
+      if (!extractedFields.has(field)) {
+        errors.push({
+          path: `/connections/httpLinks/${index}/matchApiBy`,
+          message: `customType "${httpLink.fromCustomType}" does not extract "${field}". Add extract["${field}"] to that custom type.`
+        });
+      }
+    }
+    return errors;
+  });
+}
+function validateConnectionsConfig(config) {
+  if (config.connections === void 0) {
+    return [];
+  }
+  const customTypeFields = collectCustomTypeExtractedFields(config);
+  return [
+    ...validateEventPublishers2(config.connections, customTypeFields),
+    ...validateHttpLinks2(config.connections, customTypeFields)
+  ];
+}
+function validateExtractionConfigSchema(data) {
+  const schemaValid = validate(data) === true;
+  if (!schemaValid) {
+    return {
+      valid: false,
+      errors: mapAjvErrors(validate.errors)
+    };
+  }
+  return {
+    valid: true,
+    errors: []
+  };
+}
+function validateExtractionConfig(data) {
+  if (!isValidExtractionConfig(data)) {
+    return validateExtractionConfigSchema(data);
+  }
+  const semanticErrors = [...validateAllExtractionRules(data), ...validateConnectionsConfig(data)];
+  if (semanticErrors.length > 0) {
+    return {
+      valid: false,
+      errors: semanticErrors
+    };
+  }
+  return {
+    valid: true,
+    errors: []
+  };
+}
+function parseExtractionConfigSchema(data) {
+  const result = validateExtractionConfigSchema(data);
+  if (result.valid && isValidExtractionConfig(data)) {
+    return { success: true, configuration: data };
+  }
+  return { success: false, errors: result.errors };
+}
+function parseExtractionConfig(data) {
+  const result = validateExtractionConfig(data);
+  if (result.valid && isValidExtractionConfig(data)) {
+    return { success: true, configuration: data };
+  }
+  return { success: false, errors: result.errors };
+}
+export {
+  ValidatedConfiguration,
+  ValidatedModule,
+  parseExtractionConfig,
+  parseExtractionConfigSchema
+};