@carbonbox/domain 0.8.6 → 0.8.8

package/build/carbonbox/emission-calculation-formulas/domain/value-objects/EmissionCalculationFormulaExpression.js

@@ -4,18 +4,39 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _EmissionCalculationFormulaExpression_instances, _a, _EmissionCalculationFormulaExpression_guardAgainstInvalidLength, _EmissionCalculationFormulaExpression_guardAgainstInvalidFormulaStructure;
+var _EmissionCalculationFormulaExpression_instances, _a, _EmissionCalculationFormulaExpression_guardAgainstInvalidLength, _EmissionCalculationFormulaExpression_guardAgainstInsecureContent;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EmissionCalculationFormulaExpression = void 0;
 const String_1 = require("../../../shared/domain/value-objects/String");
 const InvalidPropertyValueError_1 = require("../../../shared/domain/exceptions/InvalidPropertyValueError");
+/**
+ * Domain value object for the formula expression string.
+ *
+ * The domain validates only what can be enforced without parsing the
+ * expression as math (the `@carbonbox/domain` package is zero-dependency
+ * by design — see CLAUDE.md):
+ *
+ *  - Empty / type / length boundaries (storage invariants).
+ *  - Defense-in-depth against script-injection-shaped substrings.
+ *
+ * The mathematical correctness of the expression — syntax, allowed
+ * functions, and that every referenced symbol is declared on the
+ * parent formula (variables + reserved `EF`/`GWP` tokens) — is a
+ * concern of the application layer, where `IFormulaValidationApplicationService`
+ * (backed by mathjs) parses the expression as a real AST.
+ *
+ * The handlers that build / activate / update a formula MUST run that
+ * application-side validation before constructing this VO. The VO does
+ * not assert it directly because doing so would require importing a
+ * mathematical parser into the pure domain layer.
+ */
 class EmissionCalculationFormulaExpression extends String_1.String {
     constructor(value, skipDomainValidation) {
         super(value, skipDomainValidation, _a.PROPERTY_NAME);
         _EmissionCalculationFormulaExpression_instances.add(this);
         if (skipDomainValidation === false) {
             __classPrivateFieldGet(this, _EmissionCalculationFormulaExpression_instances, "m", _EmissionCalculationFormulaExpression_guardAgainstInvalidLength).call(this, value);
-            __classPrivateFieldGet(this, _EmissionCalculationFormulaExpression_instances, "m", _EmissionCalculationFormulaExpression_guardAgainstInvalidFormulaStructure).call(this, value);
+            __classPrivateFieldGet(this, _EmissionCalculationFormulaExpression_instances, "m", _EmissionCalculationFormulaExpression_guardAgainstInsecureContent).call(this, value);
         }
     }
     static create(value) {
@@ -24,20 +45,11 @@ class EmissionCalculationFormulaExpression extends String_1.String {
         return new _a(value, false);
     }
     static fromPrimitives(primitive) {
-        const value = primitive;
-        return new _a(value, true);
+        return new _a(primitive, true);
     }
     toPrimitives() {
         return this.value;
     }
-    containsVariable(variableSymbol) {
-        return this.value.includes(variableSymbol);
-    }
-    getVariableSymbols() {
-        const variablePattern = /\b[A-Z][A-Z0-9]*\b/g;
-        const matches = this.value.match(variablePattern) || [];
-        return [...new Set(matches)].filter((match) => match !== 'EF' && match !== 'GWP');
-    }
 }
 exports.EmissionCalculationFormulaExpression = EmissionCalculationFormulaExpression;
 _a = EmissionCalculationFormulaExpression, _EmissionCalculationFormulaExpression_instances = new WeakSet(), _EmissionCalculationFormulaExpression_guardAgainstInvalidLength = function _EmissionCalculationFormulaExpression_guardAgainstInvalidLength(value) {
@@ -47,24 +59,20 @@ _a = EmissionCalculationFormulaExpression, _EmissionCalculationFormulaExpression
     if (value.length > _a.MAX_LENGTH) {
         throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(_a.PROPERTY_NAME, `at most ${_a.MAX_LENGTH} characters`, `${value.length} characters: "${value.substring(0, 50)}${value.length > 50 ? '...' : ''}"`);
     }
-}, _EmissionCalculationFormulaExpression_guardAgainstInvalidFormulaStructure = function _EmissionCalculationFormulaExpression_guardAgainstInvalidFormulaStructure(value) {
-    const requiredComponents = ['EF', 'GWP'];
-    for (const component of requiredComponents) {
-        if (!value.includes(component)) {
-            const componentName = component === 'EF' ? 'Emission Factor' : 'Global Warming Potential';
-            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(_a.PROPERTY_NAME, `contain ${component} (${componentName})`, `missing required component: ${component}`);
-        }
-    }
-    if (!value.includes('*') && !value.includes('×')) {
-        throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(_a.PROPERTY_NAME, 'contain multiplication operators (* or ×)', 'no multiplication operators found');
-    }
-    const forbiddenChars = ['<script>', '</script>', 'eval(', 'function('];
-    for (const forbiddenChar of forbiddenChars) {
-        if (value.toLowerCase().includes(forbiddenChar)) {
-            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(_a.PROPERTY_NAME, 'safe formula content', `forbidden content found: ${forbiddenChar}`);
+}, _EmissionCalculationFormulaExpression_guardAgainstInsecureContent = function _EmissionCalculationFormulaExpression_guardAgainstInsecureContent(value) {
+    const lowered = value.toLowerCase();
+    for (const forbidden of _a.FORBIDDEN_SUBSTRINGS) {
+        if (lowered.includes(forbidden)) {
+            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(_a.PROPERTY_NAME, 'safe formula content', `forbidden content found: ${forbidden}`);
         }
     }
 };
 EmissionCalculationFormulaExpression.PROPERTY_NAME = 'expression';
 EmissionCalculationFormulaExpression.MIN_LENGTH = 5;
 EmissionCalculationFormulaExpression.MAX_LENGTH = 2000;
+EmissionCalculationFormulaExpression.FORBIDDEN_SUBSTRINGS = [
+    '<script>',
+    '</script>',
+    'eval(',
+    'function(',
+];

package/build/types/carbonbox/emission-calculation-formulas/domain/value-objects/EmissionCalculationFormulaExpression.d.ts

@@ -1,14 +1,34 @@
 import { String } from '../../../shared/domain/value-objects/String';
+/**
+ * Domain value object for the formula expression string.
+ *
+ * The domain validates only what can be enforced without parsing the
+ * expression as math (the `@carbonbox/domain` package is zero-dependency
+ * by design — see CLAUDE.md):
+ *
+ *  - Empty / type / length boundaries (storage invariants).
+ *  - Defense-in-depth against script-injection-shaped substrings.
+ *
+ * The mathematical correctness of the expression — syntax, allowed
+ * functions, and that every referenced symbol is declared on the
+ * parent formula (variables + reserved `EF`/`GWP` tokens) — is a
+ * concern of the application layer, where `IFormulaValidationApplicationService`
+ * (backed by mathjs) parses the expression as a real AST.
+ *
+ * The handlers that build / activate / update a formula MUST run that
+ * application-side validation before constructing this VO. The VO does
+ * not assert it directly because doing so would require importing a
+ * mathematical parser into the pure domain layer.
+ */
 export declare class EmissionCalculationFormulaExpression extends String {
     #private;
     private static readonly PROPERTY_NAME;
     private static readonly MIN_LENGTH;
     private static readonly MAX_LENGTH;
+    private static readonly FORBIDDEN_SUBSTRINGS;
     private constructor();
     static create(value: string): EmissionCalculationFormulaExpression;
     static fromPrimitives(primitive: string): EmissionCalculationFormulaExpression;
     toPrimitives(): string;
-    containsVariable(variableSymbol: string): boolean;
-    getVariableSymbols(): string[];
 }
 //# sourceMappingURL=EmissionCalculationFormulaExpression.d.ts.map

package/build/types/carbonbox/emission-calculation-formulas/domain/value-objects/EmissionCalculationFormulaExpression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EmissionCalculationFormulaExpression.d.ts","sourceRoot":"","sources":["../../../../../../src/carbonbox/emission-calculation-formulas/domain/value-objects/EmissionCalculationFormulaExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,6CAA6C,CAAC;AAGrE,qBAAa,oCAAqC,SAAQ,MAAM;;IAC9D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAErD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAK;IAEvC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAQ;IAE1C,OAAO;WASgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,oCAAoC;WAO3D,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,oCAAoC;IAyD9E,YAAY,IAAI,MAAM;IAI/B,gBAAgB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO;IAIjD,kBAAkB,IAAI,MAAM,EAAE;CAKtC"}
+{"version":3,"file":"EmissionCalculationFormulaExpression.d.ts","sourceRoot":"","sources":["../../../../../../src/carbonbox/emission-calculation-formulas/domain/value-objects/EmissionCalculationFormulaExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,6CAA6C,CAAC;AAGrE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,oCAAqC,SAAQ,MAAM;;IAC9D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAErD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAK;IAEvC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAQ;IAE1C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,oBAAoB,CAK1C;IAEF,OAAO;WASgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,oCAAoC;WAO3D,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,oCAAoC;IA0C9E,YAAY,IAAI,MAAM;CAGvC"}

package/package.json

@@ -3,7 +3,7 @@
     "browser": false
   },
   "name": "@carbonbox/domain",
-  "version": "0.8.6",
+  "version": "0.8.8",
   "description": "Domain package for CarbonBox Project",
   "main": "build/main/index.js",
   "types": "build/types/main/index.d.ts",