@oondemand/oon-core-back 0.3.40 → 0.3.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oondemand/oon-core-back",
-  "version": "0.3.40",
+  "version": "0.3.41",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/oondemand/oon-platform.git",

package/src/core/factories/crudController.js

@@ -1,5 +1,6 @@
 const Helpers = require("../utils/helpers");
 const registry = require("../registry");
+const { applyDomainMutation } = require("../../manifest/domainRules");
 
 function toPlainRecord(record) {
   if (!record || typeof record !== "object") return {};
@@ -9,37 +10,83 @@ function toPlainRecord(record) {
   return { ...record };
 }
 
+function hasDomainRules(entry) {
+  const rules = entry?.definition?.domainRules;
+  return Boolean(
+    rules
+    && ((rules.readonlyFields || []).length
+      || (rules.computedFields || []).length
+      || (rules.validations || []).length),
+  );
+}
+
 /**
- * Controllers HTTP de CRUD ligados a um service. Aplica validação
- * declarada via `defineValidation` antes de create/update.
+ * Controllers HTTP de CRUD ligados a um service. Aplica regras declarativas do
+ * manifesto e validações registradas via `defineValidation` antes de persistir.
  *
  * Atualizações podem chegar parcialmente pelo formulário em abas ou pelo
- * datagrid. Nesses casos, a validação recebe o registro consolidado, enquanto
- * o service persiste somente os campos enviados pelo cliente.
+ * datagrid. Nesses casos, fórmulas e validações recebem o registro consolidado,
+ * enquanto o service persiste somente os campos enviados e calculados.
  */
 function createCrudController(entry, service) {
-  const runValidation = async (data, context) => {
+  const runCustomValidation = async (data, context) => {
     const validate = registry.getValidation(entry.name);
     if (validate) await validate(data, context);
   };
 
-  const runUpdateValidation = async (id, changes, method) => {
+  const prepareCreate = async (data, method = "post") => {
+    const prepared = applyDomainMutation({
+      rules: entry.definition?.domainRules,
+      current: null,
+      changes: data,
+      op: "create",
+    });
+
+    await runCustomValidation(prepared.consolidated, {
+      op: "create",
+      method,
+      current: null,
+      requestedChanges: prepared.requestedChanges,
+      changes: prepared.changes,
+      consolidated: prepared.consolidated,
+    });
+    return prepared;
+  };
+
+  const prepareUpdate = async (id, changes, method) => {
     const validate = registry.getValidation(entry.name);
-    if (!validate) return;
+    if (!validate && !hasDomainRules(entry)) {
+      const normalizedChanges = changes && typeof changes === "object" ? { ...changes } : {};
+      return {
+        current: null,
+        requestedChanges: normalizedChanges,
+        changes: normalizedChanges,
+        consolidated: normalizedChanges,
+      };
+    }
 
     const currentRecord = await service.getById(id);
     const current = toPlainRecord(currentRecord);
-    const normalizedChanges = changes && typeof changes === "object" ? { ...changes } : {};
-    const consolidated = { ...current, ...normalizedChanges };
-
-    await validate(consolidated, {
-      op: "update",
-      method,
-      id,
+    const prepared = applyDomainMutation({
+      rules: entry.definition?.domainRules,
       current,
-      changes: normalizedChanges,
-      consolidated,
+      changes,
+      op: "update",
     });
+
+    if (validate) {
+      await validate(prepared.consolidated, {
+        op: "update",
+        method,
+        id,
+        current,
+        requestedChanges: prepared.requestedChanges,
+        changes: prepared.changes,
+        consolidated: prepared.consolidated,
+      });
+    }
+
+    return { current, ...prepared };
   };
 
   return {
@@ -61,29 +108,20 @@ function createCrudController(entry, service) {
     },
 
     async create(req, res) {
-      const data = req.body ?? {};
-      await runValidation(data, {
-        op: "create",
-        method: "post",
-        current: null,
-        changes: data,
-        consolidated: data,
-      });
-      const registro = await service.create(data);
+      const prepared = await prepareCreate(req.body ?? {}, "post");
+      const registro = await service.create(prepared.changes);
       Helpers.sendResponse({ res, statusCode: 201, [entry.singular]: registro });
     },
 
     async update(req, res) {
-      const changes = req.body ?? {};
-      await runUpdateValidation(req.params.id, changes, "put");
-      const registro = await service.update(req.params.id, changes);
+      const prepared = await prepareUpdate(req.params.id, req.body ?? {}, "put");
+      const registro = await service.update(req.params.id, prepared.changes);
       Helpers.sendResponse({ res, statusCode: 200, [entry.singular]: registro });
     },
 
     async patch(req, res) {
-      const changes = req.body ?? {};
-      await runUpdateValidation(req.params.id, changes, "patch");
-      const registro = await service.update(req.params.id, changes);
+      const prepared = await prepareUpdate(req.params.id, req.body ?? {}, "patch");
+      const registro = await service.update(req.params.id, prepared.changes);
       Helpers.sendResponse({ res, statusCode: 200, [entry.singular]: registro });
     },
 
@@ -93,7 +131,11 @@ function createCrudController(entry, service) {
     },
 
     async importMany(req, res) {
-      const result = await service.importMany(req.body?.rows || req.body);
+      const rows = req.body?.rows || req.body;
+      const preparedRows = Array.isArray(rows)
+        ? await Promise.all(rows.map(async (row) => (await prepareCreate(row, "import")).changes))
+        : rows;
+      const result = await service.importMany(preparedRows);
       Helpers.sendResponse({ res, statusCode: 201, ...result });
     },
 
@@ -104,4 +146,4 @@ function createCrudController(entry, service) {
   };
 }
 
-module.exports = { createCrudController, toPlainRecord };
+module.exports = { createCrudController, toPlainRecord, hasDomainRules };

package/src/index.js

@@ -16,6 +16,7 @@ const registry = require("./core/registry");
 const GenericError = require("./core/errors/GenericError");
 const { omie } = require("./modules/omie");
 const domainManifest = require("./manifest/domainManifest");
+const domainRules = require("./manifest/domainRules");
 
 module.exports = {
   // boot
@@ -38,11 +39,15 @@ module.exports = {
   DOMAIN_MANIFEST_FILENAME: domainManifest.DOMAIN_MANIFEST_FILENAME,
   DOMAIN_MANIFEST_SCHEMA_VERSION: domainManifest.DOMAIN_MANIFEST_SCHEMA_VERSION,
   SUPPORTED_DOMAIN_FIELD_KINDS: domainManifest.SUPPORTED_FIELD_KINDS,
+  DOMAIN_EXPRESSION_OPERATORS: domainRules.EXPRESSION_OPERATORS,
   DomainManifestError: domainManifest.DomainManifestError,
+  DomainRuleError: domainRules.DomainRuleError,
   validateDomainManifest: domainManifest.validateDomainManifest,
   domainManifestToDefinitions: domainManifest.domainManifestToDefinitions,
   registerDomainManifest: domainManifest.registerDomainManifest,
   loadDomainManifest: domainManifest.loadDomainManifest,
+  evaluateDomainExpression: domainRules.evaluateDomainExpression,
+  applyDomainMutation: domainRules.applyDomainMutation,
 
   // helpers
   fields,

package/src/manifest/domainManifest.js

@@ -4,6 +4,7 @@ const fs = require("node:fs");
 const path = require("node:path");
 const { defineModel } = require("../core/define");
 const fields = require("../core/fields");
+const { EXPRESSION_OPERATORS } = require("./domainRules");
 
 const DOMAIN_MANIFEST_FILENAME = "central.domain.json";
 const DOMAIN_MANIFEST_SCHEMA_VERSION = 1;
@@ -19,6 +20,30 @@ const SUPPORTED_FIELD_KINDS = Object.freeze([
   "currencyConverted",
 ]);
 const SUPPORTED_FIELD_KIND_SET = new Set(SUPPORTED_FIELD_KINDS);
+const EXPRESSION_OPERATOR_SET = new Set(EXPRESSION_OPERATORS);
+const NUMERIC_FIELD_KINDS = new Set(["number", "currency", "currencyConverted"]);
+const EXPRESSION_ARITY = Object.freeze({
+  add: { min: 1 },
+  subtract: { min: 2 },
+  multiply: { min: 1 },
+  divide: { min: 2 },
+  min: { min: 1 },
+  max: { min: 1 },
+  abs: { exact: 1 },
+  negate: { exact: 1 },
+  coalesce: { min: 1 },
+  eq: { exact: 2 },
+  neq: { exact: 2 },
+  gt: { exact: 2 },
+  gte: { exact: 2 },
+  lt: { exact: 2 },
+  lte: { exact: 2 },
+  and: { min: 1 },
+  or: { min: 1 },
+  not: { exact: 1 },
+  present: { exact: 1 },
+  in: { exact: 2 },
+});
 
 class DomainManifestError extends Error {
   constructor(message, issues = [], options = {}) {
@@ -75,7 +100,105 @@ function validateNumberOption(field, optionName, fieldPath, issues) {
   }
 }
 
-function validateField(fieldName, field, fieldPath, issues) {
+function expressionKind(expression) {
+  const kinds = ["value", "field", "op"].filter((key) => hasOwn(expression, key));
+  return kinds.length === 1 ? kinds[0] : null;
+}
+
+function validateExpression(expression, expressionPath, issues, fieldNames) {
+  if (!isPlainObject(expression)) {
+    addIssue(issues, expressionPath, "deve ser um objeto de expressão.");
+    return;
+  }
+
+  const kind = expressionKind(expression);
+  if (!kind) {
+    addIssue(issues, expressionPath, "deve declarar exatamente um entre value, field ou op.");
+    return;
+  }
+
+  if (kind === "value") {
+    if (!isJsonValue(expression.value)) {
+      addIssue(issues, `${expressionPath}.value`, "deve conter somente um valor JSON.");
+    }
+    return;
+  }
+
+  if (kind === "field") {
+    if (typeof expression.field !== "string" || !expression.field.trim()) {
+      addIssue(issues, `${expressionPath}.field`, "deve ser texto não vazio.");
+      return;
+    }
+    const rootField = expression.field.split(".")[0];
+    if (!fieldNames.has(rootField)) {
+      addIssue(issues, `${expressionPath}.field`, `campo não declarado: ${rootField}.`);
+    }
+    return;
+  }
+
+  if (!EXPRESSION_OPERATOR_SET.has(expression.op)) {
+    addIssue(
+      issues,
+      `${expressionPath}.op`,
+      `operador não suportado. Use: ${EXPRESSION_OPERATORS.join(", ")}.`,
+    );
+  }
+  if (!Array.isArray(expression.args)) {
+    addIssue(issues, `${expressionPath}.args`, "deve ser uma lista.");
+    return;
+  }
+
+  const arity = EXPRESSION_ARITY[expression.op];
+  if (arity?.exact !== undefined && expression.args.length !== arity.exact) {
+    addIssue(issues, `${expressionPath}.args`, `deve conter exatamente ${arity.exact} argumento(s).`);
+  }
+  if (arity?.min !== undefined && expression.args.length < arity.min) {
+    addIssue(issues, `${expressionPath}.args`, `deve conter ao menos ${arity.min} argumento(s).`);
+  }
+
+  expression.args.forEach((arg, index) => {
+    validateExpression(arg, `${expressionPath}.args[${index}]`, issues, fieldNames);
+  });
+}
+
+function collectExpressionFields(expression, result = new Set()) {
+  if (!isPlainObject(expression)) return result;
+  if (typeof expression.field === "string") result.add(expression.field.split(".")[0]);
+  if (Array.isArray(expression.args)) {
+    expression.args.forEach((arg) => collectExpressionFields(arg, result));
+  }
+  return result;
+}
+
+function validateComputedField(field, fieldPath, issues, fieldNames) {
+  if (!hasOwn(field, "computed")) return;
+  if (!isPlainObject(field.computed)) {
+    addIssue(issues, `${fieldPath}.computed`, "deve ser um objeto.");
+    return;
+  }
+  if (!NUMERIC_FIELD_KINDS.has(field.kind)) {
+    addIssue(issues, `${fieldPath}.computed`, "é permitido somente em campos number ou monetários.");
+  }
+  if (!hasOwn(field.computed, "expression")) {
+    addIssue(issues, `${fieldPath}.computed.expression`, "é obrigatória.");
+  } else {
+    validateExpression(field.computed.expression, `${fieldPath}.computed.expression`, issues, fieldNames);
+  }
+  if (hasOwn(field.computed, "precision")
+    && (!Number.isInteger(field.computed.precision)
+      || field.computed.precision < 0
+      || field.computed.precision > 8)) {
+    addIssue(issues, `${fieldPath}.computed.precision`, "deve ser inteiro entre 0 e 8.");
+  }
+  if (hasOwn(field.computed, "nullAsZero") && typeof field.computed.nullAsZero !== "boolean") {
+    addIssue(issues, `${fieldPath}.computed.nullAsZero`, "deve ser booleano.");
+  }
+  if (field.readonly === false) {
+    addIssue(issues, `${fieldPath}.readonly`, "campos calculados são sempre somente leitura.");
+  }
+}
+
+function validateField(fieldName, field, fieldPath, issues, fieldNames) {
   if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(fieldName)) {
     addIssue(issues, fieldPath, "o nome do campo deve ser um identificador JavaScript válido.");
   }
@@ -134,6 +257,96 @@ function validateField(fieldName, field, fieldPath, issues) {
     && (typeof field.base !== "string" || !/^[A-Za-z]{3}$/.test(field.base))) {
     addIssue(issues, `${fieldPath}.base`, "deve ser um código de moeda com três letras.");
   }
+
+  validateComputedField(field, fieldPath, issues, fieldNames);
+}
+
+function validateModelValidations(model, modelPath, issues, fieldNames) {
+  if (!hasOwn(model, "validations")) return;
+  if (!Array.isArray(model.validations)) {
+    addIssue(issues, `${modelPath}.validations`, "deve ser uma lista.");
+    return;
+  }
+
+  const names = new Set();
+  model.validations.forEach((validation, index) => {
+    const validationPath = `${modelPath}.validations[${index}]`;
+    if (!isPlainObject(validation)) {
+      addIssue(issues, validationPath, "deve ser um objeto.");
+      return;
+    }
+    if (typeof validation.name !== "string" || !validation.name.trim()) {
+      addIssue(issues, `${validationPath}.name`, "é obrigatório e deve ser texto não vazio.");
+    } else if (names.has(validation.name)) {
+      addIssue(issues, `${validationPath}.name`, `validação duplicada: ${validation.name}.`);
+    } else {
+      names.add(validation.name);
+    }
+    if (typeof validation.message !== "string" || !validation.message.trim()) {
+      addIssue(issues, `${validationPath}.message`, "é obrigatória e deve ser texto não vazio.");
+    }
+    if (hasOwn(validation, "code")
+      && (typeof validation.code !== "string" || !/^[A-Z][A-Z0-9_]*$/.test(validation.code))) {
+      addIssue(issues, `${validationPath}.code`, "deve usar letras maiúsculas, números e sublinhado.");
+    }
+    if (hasOwn(validation, "field")) {
+      if (typeof validation.field !== "string" || !fieldNames.has(validation.field.split(".")[0])) {
+        addIssue(issues, `${validationPath}.field`, "deve apontar para um campo declarado.");
+      }
+    }
+    if (!hasOwn(validation, "assert")) {
+      addIssue(issues, `${validationPath}.assert`, "é obrigatória.");
+    } else {
+      validateExpression(validation.assert, `${validationPath}.assert`, issues, fieldNames);
+    }
+    if (hasOwn(validation, "when")) {
+      validateExpression(validation.when, `${validationPath}.when`, issues, fieldNames);
+    }
+  });
+}
+
+function computedDependencies(model) {
+  const result = new Map();
+  const computedNames = new Set(
+    Object.entries(model.fields)
+      .filter(([, field]) => isPlainObject(field?.computed))
+      .map(([fieldName]) => fieldName),
+  );
+  for (const [fieldName, field] of Object.entries(model.fields)) {
+    if (!isPlainObject(field?.computed)) continue;
+    const dependencies = [...collectExpressionFields(field.computed.expression)]
+      .filter((dependency) => computedNames.has(dependency));
+    result.set(fieldName, dependencies);
+  }
+  return result;
+}
+
+function validateComputedCycles(model, modelPath, issues) {
+  const dependencies = computedDependencies(model);
+  const visited = new Set();
+  const visiting = new Set();
+
+  function visit(fieldName, trail = []) {
+    if (visited.has(fieldName)) return;
+    if (visiting.has(fieldName)) {
+      const cycleStart = trail.indexOf(fieldName);
+      const cycle = [...trail.slice(cycleStart), fieldName];
+      addIssue(
+        issues,
+        `${modelPath}.fields.${fieldName}.computed.expression`,
+        `dependência circular entre campos calculados: ${cycle.join(" -> ")}.`,
+      );
+      return;
+    }
+    visiting.add(fieldName);
+    for (const dependency of dependencies.get(fieldName) || []) {
+      visit(dependency, [...trail, fieldName]);
+    }
+    visiting.delete(fieldName);
+    visited.add(fieldName);
+  }
+
+  for (const fieldName of dependencies.keys()) visit(fieldName);
 }
 
 function validateModel(model, index, issues, modelNames) {
@@ -167,9 +380,12 @@ function validateModel(model, index, issues, modelNames) {
     return;
   }
 
+  const fieldNames = new Set(Object.keys(model.fields));
   for (const [fieldName, field] of Object.entries(model.fields)) {
-    validateField(fieldName, field, `${modelPath}.fields.${fieldName}`, issues);
+    validateField(fieldName, field, `${modelPath}.fields.${fieldName}`, issues, fieldNames);
   }
+  validateModelValidations(model, modelPath, issues, fieldNames);
+  validateComputedCycles(model, modelPath, issues);
 }
 
 function validateDomainManifest(input) {
@@ -258,7 +474,7 @@ function createFieldDescriptor(field) {
       ]);
   }
 
-  if (field.readonly) descriptor.immutable = true;
+  if (field.readonly || field.computed) descriptor.immutable = true;
   if (field.unique) descriptor.unique = true;
   if (field.index) descriptor.index = true;
   if (typeof field.min === "number") descriptor.min = field.min;
@@ -269,13 +485,46 @@ function createFieldDescriptor(field) {
   descriptor.__meta = {
     ...descriptor.__meta,
     description: field.description,
-    readonly: Boolean(field.readonly),
+    readonly: Boolean(field.readonly || field.computed),
+    computed: field.computed || undefined,
     unique: Boolean(field.unique),
     index: Boolean(field.index),
   };
   return descriptor;
 }
 
+function orderComputedFields(model) {
+  const dependencies = computedDependencies(model);
+  const ordered = [];
+  const visited = new Set();
+
+  function visit(fieldName) {
+    if (visited.has(fieldName)) return;
+    for (const dependency of dependencies.get(fieldName) || []) visit(dependency);
+    visited.add(fieldName);
+    const computed = model.fields[fieldName].computed;
+    ordered.push({
+      field: fieldName,
+      expression: computed.expression,
+      precision: computed.precision ?? 2,
+      nullAsZero: computed.nullAsZero !== false,
+    });
+  }
+
+  for (const fieldName of dependencies.keys()) visit(fieldName);
+  return ordered;
+}
+
+function createDomainRules(model) {
+  return {
+    readonlyFields: Object.entries(model.fields)
+      .filter(([, field]) => Boolean(field.readonly || field.computed))
+      .map(([fieldName]) => fieldName),
+    computedFields: orderComputedFields(model),
+    validations: model.validations || [],
+  };
+}
+
 function domainManifestToDefinitions(input) {
   const manifest = validateDomainManifest(input);
   return manifest.models.map((model) => ({
@@ -284,6 +533,7 @@ function domainManifestToDefinitions(input) {
     basePath: model.basePath,
     crud: model.crud,
     options: model.options,
+    domainRules: createDomainRules(model),
     schema: Object.fromEntries(
       Object.entries(model.fields).map(([fieldName, field]) => [
         fieldName,

package/src/manifest/domainRules.js

@@ -0,0 +1,318 @@
+"use strict";
+
+const GenericError = require("../core/errors/GenericError");
+
+const EXPRESSION_OPERATORS = Object.freeze([
+  "add",
+  "subtract",
+  "multiply",
+  "divide",
+  "min",
+  "max",
+  "abs",
+  "negate",
+  "coalesce",
+  "eq",
+  "neq",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "and",
+  "or",
+  "not",
+  "present",
+  "in",
+]);
+
+class DomainRuleError extends GenericError {
+  constructor(message, options = {}) {
+    const field = options.field || null;
+    const rule = options.rule || null;
+    super(message, {
+      statusCode: 422,
+      details: {
+        field,
+        message,
+        rule,
+        ...(options.details || {}),
+      },
+    });
+    this.name = "DomainRuleError";
+    this.code = options.code || "OON_DOMAIN_RULE_VIOLATION";
+    this.field = field;
+    this.rule = rule;
+  }
+}
+
+function hasOwn(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}
+
+function getFieldValue(record, fieldPath) {
+  if (!record || !fieldPath) return undefined;
+  const parts = String(fieldPath).split(".");
+  let current = record;
+  for (const part of parts) {
+    if (["__proto__", "prototype", "constructor"].includes(part)) return undefined;
+    if (current === null || current === undefined || typeof current !== "object") return undefined;
+    current = current[part];
+  }
+  return current;
+}
+
+function isEmpty(value) {
+  return value === null || value === undefined || (typeof value === "string" && !value.trim());
+}
+
+function toNumber(value, context = {}) {
+  if (isEmpty(value)) {
+    return context.nullAsZero ? 0 : null;
+  }
+  const numeric = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(numeric)) {
+    throw new DomainRuleError(
+      `A fórmula do campo ${context.field || "calculado"} recebeu um valor não numérico.`,
+      {
+        code: "OON_DOMAIN_FORMULA_ERROR",
+        field: context.field,
+        rule: context.rule,
+        details: { value },
+      },
+    );
+  }
+  return numeric;
+}
+
+function numericArguments(args, record, context) {
+  const values = args.map((arg) => evaluateDomainExpression(arg, record, context));
+  if (!context.nullAsZero && values.some((value) => isEmpty(value))) return null;
+  return values.map((value) => toNumber(value, context));
+}
+
+function compareValues(left, right, operator) {
+  if (["gt", "gte", "lt", "lte"].includes(operator)) {
+    const leftNumber = Number(left);
+    const rightNumber = Number(right);
+    if (Number.isFinite(leftNumber) && Number.isFinite(rightNumber)) {
+      left = leftNumber;
+      right = rightNumber;
+    }
+  }
+
+  switch (operator) {
+    case "eq": return Object.is(left, right);
+    case "neq": return !Object.is(left, right);
+    case "gt": return left > right;
+    case "gte": return left >= right;
+    case "lt": return left < right;
+    case "lte": return left <= right;
+    default: return false;
+  }
+}
+
+function evaluateDomainExpression(expression, record = {}, context = {}) {
+  if (!expression || typeof expression !== "object" || Array.isArray(expression)) {
+    throw new DomainRuleError("Expressão declarativa inválida.", {
+      code: "OON_DOMAIN_EXPRESSION_INVALID",
+      field: context.field,
+      rule: context.rule,
+    });
+  }
+
+  if (hasOwn(expression, "value")) return expression.value;
+  if (hasOwn(expression, "field")) return getFieldValue(record, expression.field);
+
+  const operator = expression.op;
+  const args = Array.isArray(expression.args) ? expression.args : [];
+
+  switch (operator) {
+    case "add": {
+      const values = numericArguments(args, record, context);
+      return values === null ? null : values.reduce((total, value) => total + value, 0);
+    }
+    case "subtract": {
+      const values = numericArguments(args, record, context);
+      return values === null ? null : values.slice(1).reduce((total, value) => total - value, values[0]);
+    }
+    case "multiply": {
+      const values = numericArguments(args, record, context);
+      return values === null ? null : values.reduce((total, value) => total * value, 1);
+    }
+    case "divide": {
+      const values = numericArguments(args, record, context);
+      if (values === null) return null;
+      return values.slice(1).reduce((total, divisor) => {
+        if (divisor === 0) {
+          throw new DomainRuleError(
+            `A fórmula do campo ${context.field || "calculado"} tentou dividir por zero.`,
+            {
+              code: "OON_DOMAIN_FORMULA_ERROR",
+              field: context.field,
+              rule: context.rule,
+            },
+          );
+        }
+        return total / divisor;
+      }, values[0]);
+    }
+    case "min": {
+      const values = numericArguments(args, record, context);
+      return values === null ? null : Math.min(...values);
+    }
+    case "max": {
+      const values = numericArguments(args, record, context);
+      return values === null ? null : Math.max(...values);
+    }
+    case "abs": {
+      const value = numericArguments(args, record, context);
+      return value === null ? null : Math.abs(value[0]);
+    }
+    case "negate": {
+      const value = numericArguments(args, record, context);
+      return value === null ? null : -value[0];
+    }
+    case "coalesce": {
+      for (const arg of args) {
+        const value = evaluateDomainExpression(arg, record, context);
+        if (!isEmpty(value)) return value;
+      }
+      return null;
+    }
+    case "eq":
+    case "neq":
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte": {
+      const left = evaluateDomainExpression(args[0], record, context);
+      const right = evaluateDomainExpression(args[1], record, context);
+      return compareValues(left, right, operator);
+    }
+    case "and":
+      return args.every((arg) => Boolean(evaluateDomainExpression(arg, record, context)));
+    case "or":
+      return args.some((arg) => Boolean(evaluateDomainExpression(arg, record, context)));
+    case "not":
+      return !Boolean(evaluateDomainExpression(args[0], record, context));
+    case "present":
+      return !isEmpty(evaluateDomainExpression(args[0], record, context));
+    case "in": {
+      const value = evaluateDomainExpression(args[0], record, context);
+      const list = evaluateDomainExpression(args[1], record, context);
+      return Array.isArray(list) && list.some((item) => Object.is(item, value));
+    }
+    default:
+      throw new DomainRuleError(`Operador declarativo não suportado: ${String(operator)}.`, {
+        code: "OON_DOMAIN_EXPRESSION_INVALID",
+        field: context.field,
+        rule: context.rule,
+      });
+  }
+}
+
+function roundValue(value, precision) {
+  if (value === null || value === undefined) return value;
+  const numeric = toNumber(value);
+  const factor = 10 ** Number(precision || 0);
+  return Math.round((numeric + Number.EPSILON) * factor) / factor;
+}
+
+function valuesEquivalent(left, right) {
+  if (Object.is(left, right)) return true;
+  if (isEmpty(left) && isEmpty(right)) return true;
+  const leftNumber = Number(left);
+  const rightNumber = Number(right);
+  return Number.isFinite(leftNumber)
+    && Number.isFinite(rightNumber)
+    && Object.is(leftNumber, rightNumber);
+}
+
+function readonlyViolation(field, rule) {
+  throw new DomainRuleError(`O campo ${field} é somente leitura e não pode ser alterado.`, {
+    code: "OON_DOMAIN_READONLY_FIELD",
+    field,
+    rule,
+  });
+}
+
+function applyDomainMutation({ rules, current = null, changes = {}, op = "update" } = {}) {
+  const requestedChanges = changes && typeof changes === "object" && !Array.isArray(changes)
+    ? { ...changes }
+    : {};
+  const sanitizedChanges = { ...requestedChanges };
+  const currentRecord = current && typeof current === "object" ? { ...current } : {};
+  const domainRules = rules || {};
+  const computedFields = Array.isArray(domainRules.computedFields)
+    ? domainRules.computedFields
+    : [];
+  const computedNames = new Set(computedFields.map((item) => item.field));
+
+  for (const field of domainRules.readonlyFields || []) {
+    if (!hasOwn(requestedChanges, field) || computedNames.has(field)) continue;
+    if (op === "update" && valuesEquivalent(requestedChanges[field], currentRecord[field])) {
+      delete sanitizedChanges[field];
+      continue;
+    }
+    readonlyViolation(field, "readonly");
+  }
+
+  for (const computed of computedFields) {
+    delete sanitizedChanges[computed.field];
+  }
+
+  const consolidated = { ...currentRecord, ...sanitizedChanges };
+
+  for (const computed of computedFields) {
+    const value = evaluateDomainExpression(computed.expression, consolidated, {
+      field: computed.field,
+      rule: "computed",
+      nullAsZero: Boolean(computed.nullAsZero),
+    });
+    const normalized = value === null || value === undefined
+      ? value
+      : roundValue(value, computed.precision);
+
+    if (hasOwn(requestedChanges, computed.field)
+      && !valuesEquivalent(requestedChanges[computed.field], normalized)) {
+      readonlyViolation(computed.field, "computed");
+    }
+
+    consolidated[computed.field] = normalized;
+    sanitizedChanges[computed.field] = normalized;
+  }
+
+  for (const validation of domainRules.validations || []) {
+    const context = {
+      field: validation.field,
+      rule: validation.name || validation.code || "validation",
+    };
+    if (validation.when
+      && !Boolean(evaluateDomainExpression(validation.when, consolidated, context))) {
+      continue;
+    }
+    if (!Boolean(evaluateDomainExpression(validation.assert, consolidated, context))) {
+      throw new DomainRuleError(validation.message, {
+        code: validation.code || "OON_DOMAIN_VALIDATION_FAILED",
+        field: validation.field,
+        rule: validation.name,
+      });
+    }
+  }
+
+  return {
+    changes: sanitizedChanges,
+    consolidated,
+    requestedChanges,
+  };
+}
+
+module.exports = {
+  EXPRESSION_OPERATORS,
+  DomainRuleError,
+  evaluateDomainExpression,
+  applyDomainMutation,
+  getFieldValue,
+  roundValue,
+  valuesEquivalent,
+};