@living-architecture/riviere-cli 0.7.23 → 0.7.25

package/dist/bin.js

@@ -25389,6 +25389,241 @@ var extraction_config_schema_default = {
         },
         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/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: {
+            position: { type: "integer", minimum: 0 },
+            name: { type: "string", minLength: 1 },
+            transform: { $ref: "#/$defs/transform" }
+          }
+        }
+      }
+    },
+    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"
         }
       }
     },
@@ -25613,6 +25848,22 @@ var extraction_config_schema_default = {
 };
 
 // ../riviere-extract-config/dist/validation.js
+var REQUIRED_FIELDS = {
+  api: ["apiType"],
+  event: ["eventName"],
+  eventHandler: ["subscribedEvents"],
+  domainOp: ["operationName"],
+  ui: ["route"],
+  useCase: []
+};
+var COMPONENT_TYPES = [
+  "api",
+  "useCase",
+  "domainOp",
+  "event",
+  "eventHandler",
+  "ui"
+];
 var ajv2 = new import_ajv2.default({ allErrors: true });
 (0, import_ajv_formats2.default)(ajv2);
 var validate2 = ajv2.compile(extraction_config_schema_default);
@@ -25644,17 +25895,78 @@ function mapAjvErrors(errors) {
     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_TYPES) {
+    const rule = module[componentType];
+    if (isNotUsed(rule)) {
+      continue;
+    }
+    if (!hasDetectionRule(rule)) {
+      continue;
+    }
+    const requiredFields = REQUIRED_FIELDS[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(config2) {
+  return config2.modules.flatMap((module, index) => {
+    if ("$ref" in module) {
+      return [];
+    }
+    return validateModuleExtractionRules(module, index);
+  });
+}
+function validateExtractionConfigSchema(data) {
+  const schemaValid = validate2(data) === true;
+  if (!schemaValid) {
+    return {
+      valid: false,
+      errors: mapAjvErrors(validate2.errors)
+    };
+  }
+  return {
+    valid: true,
+    errors: []
+  };
+}
 function validateExtractionConfig(data) {
-  const valid = validate2(data) === true;
-  if (valid) {
+  if (!isValidExtractionConfig(data)) {
+    return validateExtractionConfigSchema(data);
+  }
+  const semanticErrors = validateAllExtractionRules(data);
+  if (semanticErrors.length > 0) {
     return {
-      valid: true,
-      errors: []
+      valid: false,
+      errors: semanticErrors
     };
   }
   return {
-    valid: false,
-    errors: mapAjvErrors(validate2.errors)
+    valid: true,
+    errors: []
   };
 }
 function formatValidationErrors2(errors) {
@@ -27346,7 +27658,7 @@ function evaluateInClassWith(node, predicate) {
 }
 
 // ../riviere-extract-ts/dist/extractor.js
-var COMPONENT_TYPES = [
+var COMPONENT_TYPES2 = [
   "api",
   "useCase",
   "domainOp",
@@ -27382,7 +27694,7 @@ function extractFromFile(project, filePath, config2, configDir) {
   return extractFromModule(sourceFile, filePath, matchingModule);
 }
 function extractFromModule(sourceFile, filePath, module) {
-  const builtInComponents = COMPONENT_TYPES.flatMap((componentType) => extractComponentType(sourceFile, filePath, module, componentType));
+  const builtInComponents = COMPONENT_TYPES2.flatMap((componentType) => extractComponentType(sourceFile, filePath, module, componentType));
   const customComponents = extractCustomTypes(sourceFile, filePath, module);
   return [...builtInComponents, ...customComponents];
 }

package/dist/index.js

@@ -25406,6 +25406,241 @@ var extraction_config_schema_default = {
         },
         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/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: {
+            position: { type: "integer", minimum: 0 },
+            name: { type: "string", minLength: 1 },
+            transform: { $ref: "#/$defs/transform" }
+          }
+        }
+      }
+    },
+    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"
         }
       }
     },
@@ -25630,6 +25865,22 @@ var extraction_config_schema_default = {
 };
 
 // ../riviere-extract-config/dist/validation.js
+var REQUIRED_FIELDS = {
+  api: ["apiType"],
+  event: ["eventName"],
+  eventHandler: ["subscribedEvents"],
+  domainOp: ["operationName"],
+  ui: ["route"],
+  useCase: []
+};
+var COMPONENT_TYPES = [
+  "api",
+  "useCase",
+  "domainOp",
+  "event",
+  "eventHandler",
+  "ui"
+];
 var ajv2 = new import_ajv2.default({ allErrors: true });
 (0, import_ajv_formats2.default)(ajv2);
 var validate2 = ajv2.compile(extraction_config_schema_default);
@@ -25661,17 +25912,78 @@ function mapAjvErrors(errors) {
     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_TYPES) {
+    const rule = module[componentType];
+    if (isNotUsed(rule)) {
+      continue;
+    }
+    if (!hasDetectionRule(rule)) {
+      continue;
+    }
+    const requiredFields = REQUIRED_FIELDS[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(config2) {
+  return config2.modules.flatMap((module, index) => {
+    if ("$ref" in module) {
+      return [];
+    }
+    return validateModuleExtractionRules(module, index);
+  });
+}
+function validateExtractionConfigSchema(data) {
+  const schemaValid = validate2(data) === true;
+  if (!schemaValid) {
+    return {
+      valid: false,
+      errors: mapAjvErrors(validate2.errors)
+    };
+  }
+  return {
+    valid: true,
+    errors: []
+  };
+}
 function validateExtractionConfig(data) {
-  const valid = validate2(data) === true;
-  if (valid) {
+  if (!isValidExtractionConfig(data)) {
+    return validateExtractionConfigSchema(data);
+  }
+  const semanticErrors = validateAllExtractionRules(data);
+  if (semanticErrors.length > 0) {
     return {
-      valid: true,
-      errors: []
+      valid: false,
+      errors: semanticErrors
     };
   }
   return {
-    valid: false,
-    errors: mapAjvErrors(validate2.errors)
+    valid: true,
+    errors: []
   };
 }
 function formatValidationErrors2(errors) {
@@ -27363,7 +27675,7 @@ function evaluateInClassWith(node, predicate) {
 }
 
 // ../riviere-extract-ts/dist/extractor.js
-var COMPONENT_TYPES = [
+var COMPONENT_TYPES2 = [
   "api",
   "useCase",
   "domainOp",
@@ -27399,7 +27711,7 @@ function extractFromFile(project, filePath, config2, configDir) {
   return extractFromModule(sourceFile, filePath, matchingModule);
 }
 function extractFromModule(sourceFile, filePath, module) {
-  const builtInComponents = COMPONENT_TYPES.flatMap((componentType) => extractComponentType(sourceFile, filePath, module, componentType));
+  const builtInComponents = COMPONENT_TYPES2.flatMap((componentType) => extractComponentType(sourceFile, filePath, module, componentType));
   const customComponents = extractCustomTypes(sourceFile, filePath, module);
   return [...builtInComponents, ...customComponents];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@living-architecture/riviere-cli",
-  "version": "0.7.23",
+  "version": "0.7.25",
   "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.5.22",
-    "@living-architecture/riviere-extract-config": "0.3.3",
-    "@living-architecture/riviere-extract-ts": "0.1.26",
-    "@living-architecture/riviere-query": "0.4.22",
-    "@living-architecture/riviere-schema": "0.4.22"
+    "@living-architecture/riviere-extract-config": "0.3.5",
+    "@living-architecture/riviere-builder": "0.5.23",
+    "@living-architecture/riviere-extract-ts": "0.1.28",
+    "@living-architecture/riviere-schema": "0.4.23",
+    "@living-architecture/riviere-query": "0.4.23"
   }
 }