@oondemand/oon-core-back 0.3.39 → 0.3.41

package/package.json

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

package/src/boot/loadCentral.js

@@ -1,13 +1,22 @@
 const fs = require("node:fs");
 const path = require("node:path");
 const ctx = require("../core/context");
+const {
+  DOMAIN_MANIFEST_FILENAME,
+  loadDomainManifest,
+} = require("../manifest/domainManifest");
 
 /**
  * Descobre e carrega a Central do consumidor:
  *   1. `central.config.js` na raiz do projeto (mescla na config do Core);
- *   2. arquivos de domínio em `src/{models,validations,triggers,routes,
+ *   2. `central.domain.json` na raiz (registra models declarativas);
+ *   3. arquivos de domínio em `src/{models,validations,triggers,routes,
  *      pipelines,documents,integrations,mappings}` (apenas `require`,
  *      o efeito colateral é registrar via `define*`).
+ *
+ * O carregamento dos diretórios JavaScript permanece ativo durante a migração.
+ * Declarar a mesma model no manifesto e em `src/models` falha explicitamente no
+ * registry, impedindo duas fontes de verdade silenciosas.
  */
 const DOMAIN_DIRS = [
   "models",
@@ -28,6 +37,11 @@ function loadCentral(cwd = process.cwd()) {
     ctx.setConfig(typeof config === "function" ? config() : config);
   }
 
+  const domainManifestPath = path.join(cwd, DOMAIN_MANIFEST_FILENAME);
+  if (fs.existsSync(domainManifestPath)) {
+    loadDomainManifest(domainManifestPath);
+  }
+
   const srcDir = path.join(cwd, "src");
   for (const dir of DOMAIN_DIRS) {
     const full = path.join(srcDir, dir);

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

@@ -15,6 +15,8 @@ const fields = require("./core/fields");
 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
@@ -33,6 +35,20 @@ module.exports = {
   defineValidation: define.defineValidation,
   defineTrigger: define.defineTrigger,
 
+  // manifesto declarativo de domínio
+  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,
   omie,

package/src/manifest/domainManifest.js

@@ -0,0 +1,585 @@
+"use strict";
+
+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;
+const SUPPORTED_FIELD_KINDS = Object.freeze([
+  "string",
+  "number",
+  "boolean",
+  "date",
+  "ref",
+  "enum",
+  "currency",
+  "currencyCode",
+  "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 = {}) {
+    super(message, options);
+    this.name = "DomainManifestError";
+    this.code = "OON_DOMAIN_MANIFEST_INVALID";
+    this.statusCode = 422;
+    this.issues = issues;
+    this.details = { issues };
+  }
+}
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function hasOwn(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}
+
+function addIssue(issues, fieldPath, message) {
+  issues.push({ path: fieldPath, message });
+}
+
+function isJsonValue(value, seen = new Set()) {
+  if (value === null) return true;
+  if (["string", "number", "boolean"].includes(typeof value)) {
+    return typeof value !== "number" || Number.isFinite(value);
+  }
+  if (typeof value !== "object" || seen.has(value)) return false;
+
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const valid = value.every((item) => isJsonValue(item, seen));
+    seen.delete(value);
+    return valid;
+  }
+
+  const valid = Object.values(value).every((item) => isJsonValue(item, seen));
+  seen.delete(value);
+  return valid;
+}
+
+function validateBooleanOption(field, optionName, fieldPath, issues) {
+  if (hasOwn(field, optionName) && typeof field[optionName] !== "boolean") {
+    addIssue(issues, `${fieldPath}.${optionName}`, "deve ser booleano.");
+  }
+}
+
+function validateNumberOption(field, optionName, fieldPath, issues) {
+  if (hasOwn(field, optionName)
+    && (typeof field[optionName] !== "number" || !Number.isFinite(field[optionName]))) {
+    addIssue(issues, `${fieldPath}.${optionName}`, "deve ser um número finito.");
+  }
+}
+
+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.");
+  }
+  if (!isPlainObject(field)) {
+    addIssue(issues, fieldPath, "deve ser um objeto.");
+    return;
+  }
+  if (!SUPPORTED_FIELD_KIND_SET.has(field.kind)) {
+    addIssue(
+      issues,
+      `${fieldPath}.kind`,
+      `tipo não suportado. Use: ${SUPPORTED_FIELD_KINDS.join(", ")}.`,
+    );
+  }
+  if (hasOwn(field, "label") && typeof field.label !== "string") {
+    addIssue(issues, `${fieldPath}.label`, "deve ser texto.");
+  }
+  if (hasOwn(field, "description") && typeof field.description !== "string") {
+    addIssue(issues, `${fieldPath}.description`, "deve ser texto.");
+  }
+
+  for (const optionName of ["required", "readonly", "searchable", "unique", "index"]) {
+    validateBooleanOption(field, optionName, fieldPath, issues);
+  }
+  for (const optionName of ["min", "max", "minLength", "maxLength"]) {
+    validateNumberOption(field, optionName, fieldPath, issues);
+  }
+  if (typeof field.min === "number" && typeof field.max === "number" && field.min > field.max) {
+    addIssue(issues, fieldPath, "min não pode ser maior que max.");
+  }
+  if (typeof field.minLength === "number"
+    && typeof field.maxLength === "number"
+    && field.minLength > field.maxLength) {
+    addIssue(issues, fieldPath, "minLength não pode ser maior que maxLength.");
+  }
+  if (hasOwn(field, "default") && !isJsonValue(field.default)) {
+    addIssue(issues, `${fieldPath}.default`, "deve conter somente um valor JSON.");
+  }
+
+  if (field.kind === "ref" && (typeof field.ref !== "string" || !field.ref.trim())) {
+    addIssue(issues, `${fieldPath}.ref`, "é obrigatório para campos ref.");
+  }
+  if (field.kind === "enum") {
+    if (!Array.isArray(field.values) || field.values.length === 0) {
+      addIssue(issues, `${fieldPath}.values`, "deve ser uma lista não vazia para campos enum.");
+    } else {
+      const invalid = field.values.some((value) => typeof value !== "string" || !value.length);
+      if (invalid) addIssue(issues, `${fieldPath}.values`, "deve conter somente textos não vazios.");
+      if (new Set(field.values).size !== field.values.length) {
+        addIssue(issues, `${fieldPath}.values`, "não pode conter valores duplicados.");
+      }
+    }
+  }
+  if (field.kind === "currencyConverted"
+    && hasOwn(field, "base")
+    && (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) {
+  const modelPath = `models[${index}]`;
+  if (!isPlainObject(model)) {
+    addIssue(issues, modelPath, "deve ser um objeto.");
+    return;
+  }
+  if (typeof model.name !== "string" || !/^[A-Z][A-Za-z0-9]*$/.test(model.name)) {
+    addIssue(issues, `${modelPath}.name`, "deve começar com letra maiúscula e conter apenas letras e números.");
+  } else if (modelNames.has(model.name)) {
+    addIssue(issues, `${modelPath}.name`, `model duplicada: ${model.name}.`);
+  } else {
+    modelNames.add(model.name);
+  }
+  if (hasOwn(model, "singular") && (typeof model.singular !== "string" || !model.singular.trim())) {
+    addIssue(issues, `${modelPath}.singular`, "deve ser texto não vazio.");
+  }
+  if (hasOwn(model, "basePath")
+    && (typeof model.basePath !== "string" || !/^\/[a-z0-9][a-z0-9/_-]*$/i.test(model.basePath))) {
+    addIssue(issues, `${modelPath}.basePath`, "deve ser um caminho iniciado por /.");
+  }
+  if (hasOwn(model, "crud") && !isPlainObject(model.crud)) {
+    addIssue(issues, `${modelPath}.crud`, "deve ser um objeto.");
+  }
+  if (hasOwn(model, "options") && !isPlainObject(model.options)) {
+    addIssue(issues, `${modelPath}.options`, "deve ser um objeto.");
+  }
+  if (!isPlainObject(model.fields) || Object.keys(model.fields).length === 0) {
+    addIssue(issues, `${modelPath}.fields`, "deve ser um objeto com pelo menos um campo.");
+    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, fieldNames);
+  }
+  validateModelValidations(model, modelPath, issues, fieldNames);
+  validateComputedCycles(model, modelPath, issues);
+}
+
+function validateDomainManifest(input) {
+  const issues = [];
+  if (!isPlainObject(input)) {
+    throw new DomainManifestError("Manifesto de domínio inválido.", [
+      { path: "$", message: "o documento deve ser um objeto JSON." },
+    ]);
+  }
+  if (input.schemaVersion !== DOMAIN_MANIFEST_SCHEMA_VERSION) {
+    addIssue(
+      issues,
+      "schemaVersion",
+      `versão não suportada. Use ${DOMAIN_MANIFEST_SCHEMA_VERSION}.`,
+    );
+  }
+  if (typeof input.name !== "string" || !input.name.trim()) {
+    addIssue(issues, "name", "é obrigatório e deve ser texto não vazio.");
+  }
+  if (hasOwn(input, "slug")
+    && (typeof input.slug !== "string" || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(input.slug))) {
+    addIssue(issues, "slug", "deve usar letras minúsculas, números e hífens.");
+  }
+  if (!Array.isArray(input.models) || input.models.length === 0) {
+    addIssue(issues, "models", "deve ser uma lista com pelo menos uma model.");
+  } else {
+    const modelNames = new Set();
+    input.models.forEach((model, index) => validateModel(model, index, issues, modelNames));
+  }
+
+  if (issues.length) {
+    throw new DomainManifestError(
+      `Manifesto de domínio inválido: ${issues.length} problema(s) encontrado(s).`,
+      issues,
+    );
+  }
+
+  return JSON.parse(JSON.stringify(input));
+}
+
+function baseFieldOptions(field) {
+  const options = {
+    required: field.required,
+    label: field.label,
+    searchable: field.searchable,
+  };
+  if (hasOwn(field, "default")) options.default = field.default;
+  return options;
+}
+
+function createFieldDescriptor(field) {
+  const options = baseFieldOptions(field);
+  let descriptor;
+
+  switch (field.kind) {
+    case "string":
+      descriptor = fields.string(options);
+      break;
+    case "number":
+      descriptor = fields.number(options);
+      break;
+    case "boolean":
+      descriptor = fields.boolean(options);
+      break;
+    case "date":
+      descriptor = fields.date(options);
+      break;
+    case "ref":
+      descriptor = fields.ref(field.ref, options);
+      break;
+    case "enum":
+      descriptor = fields.enum(field.values, options);
+      break;
+    case "currency":
+      descriptor = fields.currency(options);
+      break;
+    case "currencyCode":
+      descriptor = fields.currencyCode(options);
+      break;
+    case "currencyConverted":
+      descriptor = fields.currencyConverted({ ...options, base: field.base });
+      break;
+    default:
+      throw new DomainManifestError("Tipo de campo não suportado após validação.", [
+        { path: "kind", message: String(field.kind) },
+      ]);
+  }
+
+  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;
+  if (typeof field.max === "number") descriptor.max = field.max;
+  if (typeof field.minLength === "number") descriptor.minlength = field.minLength;
+  if (typeof field.maxLength === "number") descriptor.maxlength = field.maxLength;
+
+  descriptor.__meta = {
+    ...descriptor.__meta,
+    description: field.description,
+    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) => ({
+    name: model.name,
+    singular: model.singular,
+    basePath: model.basePath,
+    crud: model.crud,
+    options: model.options,
+    domainRules: createDomainRules(model),
+    schema: Object.fromEntries(
+      Object.entries(model.fields).map(([fieldName, field]) => [
+        fieldName,
+        createFieldDescriptor(field),
+      ]),
+    ),
+  }));
+}
+
+function registerDomainManifest(input) {
+  const definitions = domainManifestToDefinitions(input);
+  return definitions.map((definition) => defineModel(definition));
+}
+
+function loadDomainManifest(filePath, options = {}) {
+  const resolvedPath = path.resolve(filePath);
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(resolvedPath, "utf8"));
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new DomainManifestError(
+        `JSON inválido em ${resolvedPath}.`,
+        [{ path: "$", message: error.message }],
+        { cause: error },
+      );
+    }
+    throw error;
+  }
+
+  const manifest = validateDomainManifest(parsed);
+  const definitions = domainManifestToDefinitions(manifest);
+  const entries = options.register === false
+    ? []
+    : definitions.map((definition) => defineModel(definition));
+
+  return { filePath: resolvedPath, manifest, definitions, entries };
+}
+
+module.exports = {
+  DOMAIN_MANIFEST_FILENAME,
+  DOMAIN_MANIFEST_SCHEMA_VERSION,
+  SUPPORTED_FIELD_KINDS,
+  DomainManifestError,
+  validateDomainManifest,
+  domainManifestToDefinitions,
+  registerDomainManifest,
+  loadDomainManifest,
+};

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,
+};